@zodic/shared 0.0.311 → 0.0.312

package/app/services/ArchetypeService.ts

@@ -733,28 +733,26 @@ export class ArchetypeService {
     );
   }
 
-  async recycleArchetypeNameDumpsBatch(
-    compositions: Composition[]
-  ): Promise<void> {
+  async recycleArchetypeNameDumpsBatch(compositions: Composition[]): Promise<void> {
     console.log('🔁 [Recycle] Starting recycling of archetype name dumps');
-
+  
     if (compositions.length === 0) {
       console.log('✅ [Recycle] No compositions provided for recycling');
       return;
     }
-
+  
     console.log(
       `📦 [Recycle] Total compositions to recycle: ${compositions.length}`
     );
-
+  
     // Step 1: Process each composition
     const db = this.context.drizzle();
     for (const comp of compositions) {
       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
         .select({
@@ -764,37 +762,50 @@ export class ArchetypeService {
         .from(schema.archetypeNameDumps)
         .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}`
         );
         continue;
       }
-
+  
       // 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;
           }
         }
-
+  
         if (!rawText) {
           console.log(
             `⚠️ [Recycle] No dump entry contains index ${index} for combination: ${combination}`
           );
           continue;
         }
-
+  
         // 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(
           new RegExp(`-EN ${index}\\.\\s*[^-]*(?=-EN|-PT|$)`, 's')
@@ -802,45 +813,77 @@ export class ArchetypeService {
         const ptSectionMatch = cleanedText.match(
           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;
         }
-
+  
         // Combine the extracted sections into a block for parsing
-        const block = `-EN\n${enSectionMatch[0]
-          .replace(/-EN\s*/, '')
-          .trim()}\n\n-PT\n${ptSectionMatch[0].replace(/-PT\s*/, '').trim()}`;
-
+        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;
         }
-
+  
         // Step 4: Insert the parsed data into archetypes_data
         for (const gender of ['male', 'female']) {
           const enId = `${combination}:${gender}:${index}`;
           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)
@@ -862,7 +905,10 @@ export class ArchetypeService {
                 updatedAt: new Date().getTime(),
               },
             });
-
+  
+          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)
@@ -884,25 +930,33 @@ export class ArchetypeService {
                 updatedAt: new Date().getTime(),
               },
             });
-
-          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}`
           );
         }
       }
-
+  
       console.log(`🏁 [Recycle] Finished combination: ${combination}`);
     }
-
+  
     console.log(
       `🎉 [Recycle] Completed recycling for ${compositions.length} combinations`
     );
@@ -967,50 +1021,96 @@ export class ArchetypeService {
     english: any[];
     portuguese: any[];
   } {
+    console.log(`[Parse] Starting parsing of block: ${block}`);
+  
     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) {
+      console.log(`[Parse] Processing section: ${section}`);
+  
       if (section.startsWith('EN')) {
         const lines = section.split('\n').filter((l) => l.trim());
+        console.log(
+          `[Parse] Extracted ${lines.length} lines from English section: ${JSON.stringify(lines, null, 2)}`
+        );
+  
         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) {
-          english.push({ name: nameMatch, essenceLine: essenceMatch });
+          const entry = { name: nameMatch, essenceLine: essenceMatch };
+          english.push(entry);
+          console.log(
+            `[Parse] Added English entry: ${JSON.stringify(entry, null, 2)}`
+          );
+        } else {
+          console.warn(
+            `[Parse] Skipping English section due to missing fields. nameMatch: ${nameMatch}, essenceMatch: ${essenceMatch}`
+          );
         }
       } else if (section.startsWith('PT')) {
         const lines = section.split('\n').filter((l) => l.trim());
+        console.log(
+          `[Parse] Extracted ${lines.length} lines from Portuguese section: ${JSON.stringify(lines, null, 2)}`
+        );
+  
         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) {
-          portuguese.push({
+          const entry = {
             masc: mascMatch,
             fem: femMatch,
             essenceLine: essenceMatch,
-          });
+          };
+          portuguese.push(entry);
+          console.log(
+            `[Parse] Added Portuguese entry: ${JSON.stringify(entry, null, 2)}`
+          );
+        } else {
+          console.warn(
+            `[Parse] Skipping Portuguese section due to missing fields. mascMatch: ${mascMatch}, femMatch: ${femMatch}, essenceMatch: ${essenceMatch}`
+          );
         }
+      } else {
+        console.warn(`[Parse] Unrecognized section: ${section}`);
       }
     }
-
+  
+    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.312",
   "module": "index.ts",
   "type": "module",
   "publishConfig": {