@zodic/shared 0.0.218 → 0.0.220

package/app/services/ConceptService.ts

@@ -2,7 +2,7 @@ import {
   KVNamespaceListKey,
   KVNamespaceListResult,
 } from '@cloudflare/workers-types';
-import { and, eq } from 'drizzle-orm';
+import { and, eq, sql } from 'drizzle-orm';
 import { inject, injectable } from 'inversify';
 import 'reflect-metadata';
 import { v4 as uuidv4 } from 'uuid';
@@ -16,6 +16,8 @@ import {
 import { leonardoInitImages } from '../../utils/initImages';
 import { buildConceptKVKey } from '../../utils/KVKeysBuilders';
 import { AppContext } from '../base/AppContext';
+import { drizzle } from 'drizzle-orm/d1';
+import { conceptsData } from '../../db/schema';
 
 @injectable()
 export class ConceptService {
@@ -1028,41 +1030,48 @@ export class ConceptService {
     };
   }
 
-  async regenerateDuplicateNamesForConcept(conceptSlug: Concept) {
-    console.log(`🔄 [START] Regenerating duplicate names for concept: ${conceptSlug}`);
+  async regenerateDuplicateNamesForConcept(conceptSlug: Concept, maxEntries?: number) {
+    console.log(`🔄 [START] Regenerating duplicate names for concept: ${conceptSlug}...`);
   
-    const kvCacheStore = this.context.env.KV_CONCEPT_CACHE;
-    const kvStore = this.context.env.KV_CONCEPTS;
+    const db = drizzle(this.context.env.DB);
   
-    // ✅ Get duplicate keys and used names
-    const { duplicateKeys, usedNamesEN, usedNamesPT } =
-      await this.findDuplicateNamesForConcept(conceptSlug);
+    // ✅ Step 1: Fetch duplicate entries filtered by conceptSlug
+    const duplicateEntries = await db
+      .select({
+        id: conceptsData.id,
+        name: conceptsData.name,
+        description: conceptsData.description,
+        combination: conceptsData.combination,
+      })
+      .from(conceptsData)
+      .where(
+        and(
+          eq(conceptsData.language, 'en-us'), // English version only
+          eq(conceptsData.conceptSlug, conceptSlug), // ✅ Filter by concept
+          sql`name IN (
+            SELECT name FROM concepts_data 
+            WHERE language = 'en-us' AND concept_slug = ${conceptSlug}
+            GROUP BY name HAVING COUNT(*) > 1
+          )`
+        )
+      )
+      .limit(maxEntries || 50) // ✅ Apply optional limit
+      .execute();
   
-    if (duplicateKeys.length === 0) {
+    if (!duplicateEntries.length) {
       console.log(`🎉 No duplicates found for ${conceptSlug}.`);
       return { message: `No duplicates detected for ${conceptSlug}.` };
     }
   
-    let updatedKeys: string[] = [];
-    let recentDuplicates = new Set<string>(); // ✅ Track newly generated names dynamically
+    console.log(`🔍 Found ${duplicateEntries.length} duplicate entries to process.`);
   
-    console.log(`🔍 Found ${duplicateKeys.length} duplicate keys to process.`);
+    let recentDuplicates = new Set<string>(); // ✅ Track newly generated names
+    let updatedEntries = 0;
   
-    for (const kvKeyEN of duplicateKeys) {
-      const kvKeyPT = kvKeyEN.replace(':en-us:', ':pt-br:');
+    for (const entry of duplicateEntries) {
+      const { id, name, description, combination } = entry;
   
-      const kvDataEN = (await kvStore.get(kvKeyEN, 'json')) as {
-        name: string;
-        description: string;
-      };
-      const kvDataPT = (await kvStore.get(kvKeyPT, 'json')) as { name: string };
-  
-      if (!kvDataEN || !kvDataEN.name) {
-        console.warn(`⚠️ Missing data for key: ${kvKeyEN}, skipping.`);
-        continue;
-      }
-  
-      console.log(`🎭 Processing duplicate: ${kvKeyEN} (Old Name: "${kvDataEN.name}")`);
+      console.log(`🎭 Processing duplicate ID ${id}: "${name}"`);
   
       let newNameEN: string | null = null;
       let newNamePT: string | null = null;
@@ -1077,21 +1086,21 @@ export class ConceptService {
         // ✅ Generate a new name, passing dynamically tracked duplicates
         const messages = this.context.buildLLMMessages().regenerateConceptName({
           conceptSlug,
-          oldNameEN: kvDataEN.name,
-          description: kvDataEN.description,
-          recentNames: Array.from(recentDuplicates), // ✅ Prevent reusing recent names
+          oldNameEN: name,
+          description,
+          recentNames: Array.from(recentDuplicates),
         });
   
         const aiResponse = await this.context.api().callTogether.single(messages, {});
   
         if (!aiResponse) {
-          console.warn(`⚠️ AI failed to generate a new name for ${kvKeyEN}, skipping.`);
+          console.warn(`⚠️ AI failed to generate a new name for ID ${id}, skipping.`);
           break;
         }
   
         console.log(`📝 Raw AI Response:\n${aiResponse}`);
   
-        // ✅ Correctly map concept names and gendered articles
+        // ✅ Mapping for concept names with proper PT articles
         const conceptMapping = {
           amulet: { en: "Amulet", pt: "Amuleto", articlePT: "O" },
           crown: { en: "Crown", pt: "Coroa", articlePT: "A" },
@@ -1108,83 +1117,59 @@ export class ConceptService {
         };
   
         // ✅ Strict regex matching for English and Portuguese
-        const enMatch = aiResponse.match(new RegExp(`EN:\\s*The ${conceptEN} of [A-Za-z\\s]+`));
-        const ptMatch = aiResponse.match(new RegExp(`PT:\\s*${articlePT} ${conceptPT} de [A-Za-z\\s]+`));
+        const enMatch = aiResponse.match(new RegExp(`EN:\\s*The ${conceptEN} of (.+)`));
+        const ptMatch = aiResponse.match(new RegExp(`PT:\\s*${articlePT} ${conceptPT} de (.+)`));
   
         if (!enMatch || !ptMatch) {
-          console.error(`❌ Invalid AI response format! Retrying...`);
+          console.error(`❌ Invalid AI response format for ID ${id}, retrying...`);
           continue;
         }
   
-        newNameEN = enMatch[0].replace(/^EN:\s*/, '').trim();
-        newNamePT = ptMatch[0].replace(/^PT:\s*/, '').trim();
+        newNameEN = `The ${conceptEN} of ${enMatch[1].trim()}`;
+        newNamePT = `${articlePT} ${conceptPT} de ${ptMatch[1].trim()}`;
   
         console.log(`🎨 Extracted Names: EN - "${newNameEN}", PT - "${newNamePT}"`);
   
-        // ✅ Check if the name already exists
-        if (
-          usedNamesEN.has(newNameEN) ||
-          usedNamesPT.has(newNamePT) ||
-          recentDuplicates.has(newNameEN)
-        ) {
-          console.warn(
-            `⚠️ Duplicate detected: EN - "${newNameEN}", PT - "${newNamePT}". Retrying...`
-          );
-          recentDuplicates.add(newNameEN);
-          recentDuplicates.add(newNamePT);
+        // ✅ Check for duplicate avoidance
+        if (recentDuplicates.has(newNameEN)) {
+          console.warn(`⚠️ Duplicate detected: "${newNameEN}", retrying...`);
           continue;
         }
   
         recentDuplicates.add(newNameEN);
-        recentDuplicates.add(newNamePT);
-        break; // ✅ Found unique names, exit retry loop
+        break; // ✅ Found a valid new name
       }
   
       if (!newNameEN || !newNamePT) {
-        console.error(`🚨 Failed to generate a unique name for ${kvKeyEN} after ${maxAttempts} attempts.`);
+        console.error(`🚨 Failed to generate a unique name for ID ${id} after ${maxAttempts} attempts.`);
         continue;
       }
   
-      console.log(`✅ Storing new names: EN - "${newNameEN}", PT - "${newNamePT}"`);
-  
-      // ✅ Update KV with new names (EN)
-      Object.assign(kvDataEN, { name: newNameEN });
-      await kvStore.put(kvKeyEN, JSON.stringify(kvDataEN));
+      console.log(`✅ Updating names: EN - "${newNameEN}", PT - "${newNamePT}"`);
   
-      // ✅ Update KV with new names (PT)
-      Object.assign(kvDataPT, { name: newNamePT });
-      await kvStore.put(kvKeyPT, JSON.stringify(kvDataPT));
+      // ✅ Update English name using the ID
+      await db
+        .update(conceptsData)
+        .set({ name: newNameEN })
+        .where(and(eq(conceptsData.id, id), eq(conceptsData.language, 'en-us')))
+        .execute();
   
-      // ✅ Add new names to used names sets
-      usedNamesEN.add(newNameEN);
-      usedNamesPT.add(newNamePT);
+      // ✅ Convert English ID to Portuguese ID by replacing `:en-us:` with `:pt-br:`
+      const ptId = id.replace(':en-us:', ':pt-br:');
   
-      // ✅ Collect successfully processed keys for cache update
-      updatedKeys.push(kvKeyEN);
-    }
-  
-    // ✅ Remove successfully updated keys from duplicate cache
-    if (updatedKeys.length > 0) {
-      let duplicateKeysList: string[] =
-        (await kvCacheStore.get(`cache:duplicates:${conceptSlug}`, 'json')) || [];
-  
-      console.log(`🗑️ Removing ${updatedKeys.length} resolved duplicates from cache.`);
+      // ✅ Update Portuguese name using the derived PT ID
+      await db
+        .update(conceptsData)
+        .set({ name: newNamePT })
+        .where(and(eq(conceptsData.id, ptId), eq(conceptsData.language, 'pt-br')))
+        .execute();
   
-      // ✅ Remove processed keys
-      duplicateKeysList = duplicateKeysList.filter((key) => !updatedKeys.includes(key));
+      console.log(`📝 Updated IDs: EN (${id}) -> "${newNameEN}", PT (${ptId}) -> "${newNamePT}"`);
   
-      if (duplicateKeysList.length === 0) {
-        console.log(`✅ All duplicates resolved for ${conceptSlug}, deleting cache entry.`);
-        await kvCacheStore.delete(`cache:duplicates:${conceptSlug}`);
-      } else {
-        await kvCacheStore.put(
-          `cache:duplicates:${conceptSlug}`,
-          JSON.stringify(duplicateKeysList)
-        );
-      }
+      updatedEntries++;
     }
   
-    console.log(`🎉 [COMPLETE] Duplicate names regenerated successfully for concept: ${conceptSlug}.`);
+    console.log(`🎉 [COMPLETE] Regenerated ${updatedEntries} duplicate names for concept: ${conceptSlug}.`);
     return {
       message: `Duplicate names processed and regenerated for ${conceptSlug}.`,
     };

package/package.json

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