@zodic/shared 0.0.311 → 0.0.313

package/app/services/ArchetypeService.ts

@@ -449,18 +449,36 @@ export class ArchetypeService {
 
       const { english, portuguese } = this.parseArchetypeNameBlocks(block);
 
+      // Check if parsing produced the expected number of entries
+      if (english.length !== 3 || portuguese.length !== 3) {
+        console.error(
+          `[Batch] Parsing failed for ${combination}. Expected 3 entries, got English: ${english.length}, Portuguese: ${portuguese.length}`
+        );
+        continue; // Skip this combination if parsing failed
+      }
+
       for (let j = 0; j < 3; j++) {
         const index = (j + 1).toString();
         const englishEntry = english[j];
         const ptEntry = portuguese[j];
 
-        if (await isEnglishNameDuplicate(englishEntry.name)) {
+        // Skip if either entry is missing (shouldn't happen with the above check, but added for safety)
+        if (!englishEntry || !ptEntry) {
           console.warn(
-            `⚠️ [Batch] Duplicate name skipped: ${englishEntry.name}`
+            `[Batch] Skipping index ${index} for ${combination} due to missing parsed data. English: ${JSON.stringify(
+              englishEntry
+            )}, Portuguese: ${JSON.stringify(ptEntry)}`
           );
           continue;
         }
 
+        // if (await isEnglishNameDuplicate(englishEntry.name)) {
+        //   console.warn(
+        //     `⚠️ [Batch] Duplicate name skipped: ${englishEntry.name}`
+        //   );
+        //   continue;
+        // }
+
         for (const gender of ['male', 'female']) {
           const enId = `${combination}:${gender}:${index}`;
           const ptId = `${combination}:${gender}:${index}:pt`;
@@ -753,7 +771,11 @@ export class ArchetypeService {
       const combination = [comp.sun, comp.ascendant, comp.moon].join('-');
       const indexes = comp.indexesToGenerate ?? [1, 2, 3];
 
-      console.log(`🔄 [Recycle] Processing: ${combination}`);
+      console.log(
+        `🔄 [Recycle] Processing combination: ${combination} with indexes: [${indexes.join(
+          ', '
+        )}]`
+      );
 
       // Fetch all dump entries for this combination
       const dumpEntries = await db
@@ -765,6 +787,16 @@ export class ArchetypeService {
         .where(eq(schema.archetypeNameDumps.combination, combination))
         .execute();
 
+      console.log(
+        `[Recycle] Retrieved ${
+          dumpEntries.length
+        } dump entries for ${combination}: ${JSON.stringify(
+          dumpEntries,
+          null,
+          2
+        )}`
+      );
+
       if (dumpEntries.length === 0) {
         console.log(
           `⚠️ [Recycle] No dump entries found for combination: ${combination}`
@@ -774,11 +806,18 @@ export class ArchetypeService {
 
       // Step 2: Process each missing index
       for (const index of indexes) {
+        console.log(`[Recycle] Processing index ${index} for ${combination}`);
+
         // Find a dump entry that contains the specific index
         let rawText: string | null = null;
+        let selectedEntryId: string | null = null;
         for (const entry of dumpEntries) {
-          if (entry.rawText.includes(`-EN ${index}.`)) {
+          if (entry.rawText && entry.rawText.includes(`-EN ${index}.`)) {
             rawText = entry.rawText;
+            selectedEntryId = entry.id;
+            console.log(
+              `[Recycle] Selected dump entry for index ${index} with id ${selectedEntryId}: ${rawText}`
+            );
             break;
           }
         }
@@ -791,9 +830,15 @@ export class ArchetypeService {
         }
 
         // Clean up the raw text
+        console.log(
+          `[Recycle] Cleaning rawText for index ${index}: ${rawText}`
+        );
         const cleanedText = rawText
           .replace(/###|---\s*###|-\s*###/g, '')
           .trim();
+        console.log(
+          `[Recycle] Cleaned text for index ${index}: ${cleanedText}`
+        );
 
         // Extract the specific index sections
         const enSectionMatch = cleanedText.match(
@@ -803,9 +848,22 @@ export class ArchetypeService {
           new RegExp(`-PT ${index}\\.\\s*[^-]*(?=-EN|-PT|$)`, 's')
         );
 
-        if (!enSectionMatch || !ptSectionMatch) {
+        console.log(
+          `[Recycle] Extracted sections for index ${index} - enSectionMatch: ${JSON.stringify(
+            enSectionMatch
+          )}, ptSectionMatch: ${JSON.stringify(ptSectionMatch)}`
+        );
+
+        if (
+          !enSectionMatch ||
+          !ptSectionMatch ||
+          !enSectionMatch[0] ||
+          !ptSectionMatch[0]
+        ) {
           console.log(
-            `⚠️ [Recycle] Could not extract index ${index} sections for combination: ${combination}`
+            `⚠️ [Recycle] Could not extract index ${index} sections for combination: ${combination}. enSectionMatch: ${JSON.stringify(
+              enSectionMatch
+            )}, ptSectionMatch: ${JSON.stringify(ptSectionMatch)}`
           );
           continue;
         }
@@ -814,23 +872,60 @@ export class ArchetypeService {
         const block = `-EN\n${enSectionMatch[0]
           .replace(/-EN\s*/, '')
           .trim()}\n\n-PT\n${ptSectionMatch[0].replace(/-PT\s*/, '').trim()}`;
+        console.log(`[Recycle] Constructed block for index ${index}: ${block}`);
 
         // Step 3: Parse the block
         const { english, portuguese } = this.parseArchetypeNameBlocks(block);
+        console.log(
+          `[Recycle] Parsed results for index ${index} - English: ${JSON.stringify(
+            english,
+            null,
+            2
+          )}, Portuguese: ${JSON.stringify(portuguese, null, 2)}`
+        );
 
         if (english.length === 0 || portuguese.length === 0) {
           console.error(
-            `❌ [Recycle] Parsing failed for index ${index} of combination: ${combination}`
+            `❌ [Recycle] Parsing failed for index ${index} of combination: ${combination}. Block: ${block}`
           );
+          if (block) {
+            await this.context
+              .drizzle()
+              .insert(schema.archetypeNameDumps)
+              .values({
+                id: `${combination}:${index}:${Date.now()}`,
+                combination,
+                rawText: block,
+                parsedSuccessfully: 0,
+                createdAt: Date.now(),
+              });
+            console.log(
+              `[Recycle] Logged failed parse to archetype_name_dumps for index ${index} of ${combination}`
+            );
+          } else {
+            console.error(
+              `❌ [Recycle] Cannot log failed parse to archetype_name_dumps: block is undefined`
+            );
+          }
           continue;
         }
 
         const englishEntry = english[0];
         const ptEntry = portuguese[0];
 
+        console.log(
+          `[Recycle] Extracted entries for index ${index} - englishEntry: ${JSON.stringify(
+            englishEntry,
+            null,
+            2
+          )}, ptEntry: ${JSON.stringify(ptEntry, null, 2)}`
+        );
+
         if (!englishEntry || !ptEntry) {
           console.warn(
-            `⚠️ [Recycle] Skipping index ${index} for ${combination} due to missing parsed data`
+            `⚠️ [Recycle] Skipping index ${index} for ${combination} due to missing parsed data. englishEntry: ${JSON.stringify(
+              englishEntry
+            )}, ptEntry: ${JSON.stringify(ptEntry)}`
           );
           continue;
         }
@@ -841,6 +936,9 @@ export class ArchetypeService {
           const ptId = `${combination}:${gender}:${index}:pt`;
           const ptName = gender === 'female' ? ptEntry.fem : ptEntry.masc;
 
+          console.log(
+            `[Recycle] Inserting English entry for ${combination}, index ${index}, gender ${gender}: id=${enId}, name=${englishEntry.name}, essenceLine=${englishEntry.essenceLine}`
+          );
           await this.context
             .drizzle()
             .insert(schema.archetypesData)
@@ -863,6 +961,9 @@ export class ArchetypeService {
               },
             });
 
+          console.log(
+            `[Recycle] Inserting Portuguese entry for ${combination}, index ${index}, gender ${gender}: id=${ptId}, name=${ptName}, essenceLine=${ptEntry.essenceLine}`
+          );
           await this.context
             .drizzle()
             .insert(schema.archetypesData)
@@ -885,14 +986,22 @@ export class ArchetypeService {
               },
             });
 
-          await db
-            .delete(schema.archetypeNameDumps)
-            .where(
-              eq(
-                schema.archetypeNameDumps.id,
-                dumpEntries.find((e) => e.rawText === rawText)?.id || ''
-              )
+          // Delete the processed dump entry
+          if (selectedEntryId) {
+            console.log(
+              `[Recycle] Deleting dump entry with id ${selectedEntryId} for ${combination}, index ${index}`
+            );
+            await db
+              .delete(schema.archetypeNameDumps)
+              .where(eq(schema.archetypeNameDumps.id, selectedEntryId));
+            console.log(
+              `[Recycle] Successfully deleted dump entry with id ${selectedEntryId}`
             );
+          } else {
+            console.warn(
+              `[Recycle] Could not delete dump entry for ${combination}, index ${index}: selectedEntryId is null`
+            );
+          }
 
           console.log(
             `✅ [Recycle] Saved archetype ${index} (${gender}) for ${combination}`
@@ -967,50 +1076,140 @@ export class ArchetypeService {
     english: any[];
     portuguese: any[];
   } {
+    console.log(`[Parse] Starting parsing of block: ${block}`);
+
+    // Split the block into sections based on -EN and -PT markers
     const sections = block.split(/^-EN|^-PT/m).filter((s) => s.trim());
+    console.log(
+      `[Parse] Split block into ${sections.length} sections: ${JSON.stringify(
+        sections,
+        null,
+        2
+      )}`
+    );
+
     const english: any[] = [];
     const portuguese: any[] = [];
 
-    for (const section of sections) {
-      if (section.startsWith('EN')) {
-        const lines = section.split('\n').filter((l) => l.trim());
-        const nameMatch = lines
-          .find((l) => l.includes('• Name:'))
-          ?.split('• Name:')[1]
-          ?.trim();
-        const essenceMatch = lines
-          .find((l) => l.includes('• Essence:'))
-          ?.split('• Essence:')[1]
-          ?.trim();
-
-        if (nameMatch && essenceMatch) {
-          english.push({ name: nameMatch, essenceLine: essenceMatch });
-        }
-      } else if (section.startsWith('PT')) {
-        const lines = section.split('\n').filter((l) => l.trim());
-        const mascMatch = lines
-          .find((l) => l.includes('• Masculino:'))
-          ?.split('• Masculino:')[1]
-          ?.trim();
-        const femMatch = lines
-          .find((l) => l.includes('• Feminino:'))
-          ?.split('• Feminino:')[1]
-          ?.trim();
-        const essenceMatch = lines
-          .find((l) => l.includes('• Essência:'))
-          ?.split('• Essência:')[1]
-          ?.trim();
-
-        if (mascMatch && femMatch && essenceMatch) {
-          portuguese.push({
-            masc: mascMatch,
-            fem: femMatch,
-            essenceLine: essenceMatch,
-          });
+    // Track whether we're in an EN or PT section
+    let currentLang: 'EN' | 'PT' | null = null;
+
+    for (let i = 0; i < block.length; i++) {
+      if (block.startsWith('-EN', i)) {
+        currentLang = 'EN';
+        i += 3; // Skip past "-EN"
+      } else if (block.startsWith('-PT', i)) {
+        currentLang = 'PT';
+        i += 3; // Skip past "-PT"
+      }
+    }
+
+    // Process each section
+    for (let i = 0; i < sections.length; i++) {
+      const section = sections[i].trim();
+      console.log(`[Parse] Processing section: ${section}`);
+
+      // Determine the language based on the section's position relative to -EN and -PT markers
+      const lang = i === 0 ? 'EN' : 'PT'; // First section after -EN, second after -PT
+
+      // Split the section into individual entries based on numbered markers (1., 2., 3.)
+      const entries = section.split(/\n(?=\d+\.\s*)/).filter((e) => e.trim());
+      console.log(
+        `[Parse] Split section into ${entries.length} entries: ${JSON.stringify(
+          entries,
+          null,
+          2
+        )}`
+      );
+
+      for (const entry of entries) {
+        const lines = entry.split('\n').filter((l) => l.trim());
+        console.log(
+          `[Parse] Extracted ${lines.length} lines from entry: ${JSON.stringify(
+            lines,
+            null,
+            2
+          )}`
+        );
+
+        if (lang === 'EN') {
+          const nameMatch = lines
+            .find((l) => l.includes('• Name:'))
+            ?.split('• Name:')[1]
+            ?.trim();
+          console.log(`[Parse] English nameMatch: ${nameMatch}`);
+
+          const essenceMatch = lines
+            .find((l) => l.includes('• Essence:'))
+            ?.split('• Essence:')[1]
+            ?.trim();
+          console.log(`[Parse] English essenceMatch: ${essenceMatch}`);
+
+          if (nameMatch && essenceMatch) {
+            const englishEntry = { name: nameMatch, essenceLine: essenceMatch };
+            english.push(englishEntry);
+            console.log(
+              `[Parse] Added English entry: ${JSON.stringify(
+                englishEntry,
+                null,
+                2
+              )}`
+            );
+          } else {
+            console.warn(
+              `[Parse] Skipping English entry due to missing fields. nameMatch: ${nameMatch}, essenceMatch: ${essenceMatch}`
+            );
+          }
+        } else if (lang === 'PT') {
+          const mascMatch = lines
+            .find((l) => l.includes('• Masculino:'))
+            ?.split('• Masculino:')[1]
+            ?.trim();
+          console.log(`[Parse] Portuguese mascMatch: ${mascMatch}`);
+
+          const femMatch = lines
+            .find((l) => l.includes('• Feminino:'))
+            ?.split('• Feminino:')[1]
+            ?.trim();
+          console.log(`[Parse] Portuguese femMatch: ${femMatch}`);
+
+          const essenceMatch = lines
+            .find((l) => l.includes('• Essência:'))
+            ?.split('• Essência:')[1]
+            ?.trim();
+          console.log(`[Parse] Portuguese essenceMatch: ${essenceMatch}`);
+
+          if (mascMatch && femMatch && essenceMatch) {
+            const ptEntry = {
+              masc: mascMatch,
+              fem: femMatch,
+              essenceLine: essenceMatch,
+            };
+            portuguese.push(ptEntry);
+            console.log(
+              `[Parse] Added Portuguese entry: ${JSON.stringify(
+                ptEntry,
+                null,
+                2
+              )}`
+            );
+          } else {
+            console.warn(
+              `[Parse] Skipping Portuguese entry due to missing fields. mascMatch: ${mascMatch}, femMatch: ${femMatch}, essenceMatch: ${essenceMatch}`
+            );
+          }
         }
       }
     }
 
+    console.log(
+      `[Parse] Final parsed results - English: ${JSON.stringify(
+        english,
+        null,
+        2
+      )}, Portuguese: ${JSON.stringify(portuguese, null, 2)}`
+    );
+
     return { english, portuguese };
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zodic/shared",
-  "version": "0.0.311",
+  "version": "0.0.313",
   "module": "index.ts",
   "type": "module",
   "publishConfig": {