@zodic/shared 0.0.308 → 0.0.310

package/app/services/ArchetypeService.ts

@@ -733,6 +733,181 @@ export class ArchetypeService {
     );
   }
 
+  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}`);
+
+      // Fetch all dump entries for this combination
+      const dumpEntries = await db
+        .select({
+          id: schema.archetypeNameDumps.id,
+          rawText: schema.archetypeNameDumps.rawText,
+        })
+        .from(schema.archetypeNameDumps)
+        .where(eq(schema.archetypeNameDumps.combination, combination))
+        .execute();
+
+      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) {
+        // Find a dump entry that contains the specific index
+        let rawText: string | null = null;
+        for (const entry of dumpEntries) {
+          if (entry.rawText.includes(`-EN ${index}.`)) {
+            rawText = entry.rawText;
+            break;
+          }
+        }
+
+        if (!rawText) {
+          console.log(
+            `⚠️ [Recycle] No dump entry contains index ${index} for combination: ${combination}`
+          );
+          continue;
+        }
+
+        // Clean up the raw text
+        const cleanedText = rawText
+          .replace(/###|---\s*###|-\s*###/g, '')
+          .trim();
+
+        // Extract the specific index sections
+        const enSectionMatch = cleanedText.match(
+          new RegExp(`-EN ${index}\\.\\s*[^-]*(?=-EN|-PT|$)`, 's')
+        );
+        const ptSectionMatch = cleanedText.match(
+          new RegExp(`-PT ${index}\\.\\s*[^-]*(?=-EN|-PT|$)`, 's')
+        );
+
+        if (!enSectionMatch || !ptSectionMatch) {
+          console.log(
+            `⚠️ [Recycle] Could not extract index ${index} sections for combination: ${combination}`
+          );
+          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()}`;
+
+        // Step 3: Parse the block
+        const { english, portuguese } = this.parseArchetypeNameBlocks(block);
+
+        if (english.length === 0 || portuguese.length === 0) {
+          console.error(
+            `❌ [Recycle] Parsing failed for index ${index} of combination: ${combination}`
+          );
+          continue;
+        }
+
+        const englishEntry = english[0];
+        const ptEntry = portuguese[0];
+
+        if (!englishEntry || !ptEntry) {
+          console.warn(
+            `⚠️ [Recycle] Skipping index ${index} for ${combination} due to missing parsed data`
+          );
+          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;
+
+          await this.context
+            .drizzle()
+            .insert(schema.archetypesData)
+            .values({
+              id: enId,
+              combination,
+              gender,
+              archetypeIndex: index.toString(),
+              language: 'en-us',
+              name: englishEntry.name,
+              essenceLine: englishEntry.essenceLine,
+              status: 'idle',
+            })
+            .onConflictDoUpdate({
+              target: [schema.archetypesData.id],
+              set: {
+                name: englishEntry.name,
+                essenceLine: englishEntry.essenceLine,
+                updatedAt: new Date().getTime(),
+              },
+            });
+
+          await this.context
+            .drizzle()
+            .insert(schema.archetypesData)
+            .values({
+              id: ptId,
+              combination,
+              gender,
+              archetypeIndex: index.toString(),
+              language: 'pt-br',
+              name: ptName,
+              essenceLine: ptEntry.essenceLine,
+              status: 'idle',
+            })
+            .onConflictDoUpdate({
+              target: [schema.archetypesData.id],
+              set: {
+                name: ptName,
+                essenceLine: ptEntry.essenceLine,
+                updatedAt: new Date().getTime(),
+              },
+            });
+
+          await db
+            .delete(schema.archetypeNameDumps)
+            .where(
+              eq(
+                schema.archetypeNameDumps.id,
+                dumpEntries.find((e) => e.rawText === rawText)?.id || ''
+              )
+            );
+
+          console.log(
+            `✅ [Recycle] Saved archetype ${index} (${gender}) for ${combination}`
+          );
+        }
+      }
+
+      console.log(`🏁 [Recycle] Finished combination: ${combination}`);
+    }
+
+    console.log(
+      `🎉 [Recycle] Completed recycling for ${compositions.length} combinations`
+    );
+  }
+
   async fetchMissingArchetypeCompositions(): Promise<Composition[]> {
     const db = this.context.drizzle();
     const incomplete = await this.findIncompleteCombinations();

package/package.json

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

package/utils/index.ts

@@ -1,5 +1,6 @@
 import { jwtVerify } from 'jose';
 import { AuthCtx, JWKS, Provider, ProviderInfo } from '../types';
+export { eq } from 'drizzle-orm';
 
 const base64UrlDecode = (input: string) => {
   const base64 = input.replace(/-/g, '+').replace(/_/g, '/');