@zodic/shared 0.0.226 → 0.0.228

package/app/services/ConceptService.ts

@@ -2,7 +2,7 @@ import {
   KVNamespaceListKey,
   KVNamespaceListResult,
 } from '@cloudflare/workers-types';
-import { and, eq, sql } from 'drizzle-orm';
+import { and, eq, inArray, sql } from 'drizzle-orm';
 import { drizzle } from 'drizzle-orm/d1';
 import { inject, injectable } from 'inversify';
 import 'reflect-metadata';
@@ -377,22 +377,52 @@ export class ConceptService {
   async generateContent(
     conceptSlug: Concept,
     combinationString: string,
-    override: boolean = false // ✅ New optional override parameter
+    override: boolean = false // ✅ Optional override flag
   ): Promise<void> {
     console.log(
       `🚀 Generating content for concept: ${conceptSlug}, combination: ${combinationString}, override: ${override}`
     );
 
-    const kvStore = this.context.kvConceptsStore();
-    const kvFailuresStore = this.context.kvConceptFailuresStore(); // 🔴 Replace with actual KV store
-    const kvKeyEN = buildConceptKVKey('en-us', conceptSlug, combinationString);
-    const kvKeyPT = buildConceptKVKey('pt-br', conceptSlug, combinationString);
-    const failureKey = `failures:content:${conceptSlug}:${combinationString}`;
+    const db = drizzle(this.context.env.DB); // ✅ Initialize Drizzle with Cloudflare D1
 
-    // ✅ Ensure basic info is available before generating content
-    const conceptEN = await this.getKVConcept(kvKeyEN);
-    const conceptPT = await this.getKVConcept(kvKeyPT);
+    // ✅ Fetch concept data from D1
+    console.log(
+      `📡 Fetching concept data for ${conceptSlug}:${combinationString}`
+    );
+
+    const conceptEntries = await db
+      .select({
+        id: conceptsData.id,
+        language: conceptsData.language,
+        name: conceptsData.name,
+        description: conceptsData.description,
+        poem: conceptsData.poem,
+        content: conceptsData.content,
+      })
+      .from(conceptsData)
+      .where(
+        and(
+          eq(conceptsData.conceptSlug, conceptSlug),
+          eq(conceptsData.combination, combinationString),
+          inArray(conceptsData.language, ['en-us', 'pt-br']) // ✅ Fetch both languages
+        )
+      )
+      .execute();
+
+    if (conceptEntries.length !== 2) {
+      throw new Error(
+        `❌ Missing concept data for ${conceptSlug}:${combinationString}. Ensure basic info is populated first.`
+      );
+    }
+
+    const conceptEN = conceptEntries.find((c) => c.language === 'en-us');
+    const conceptPT = conceptEntries.find((c) => c.language === 'pt-br');
 
+    if (!conceptEN || !conceptPT) {
+      throw new Error(`❌ Could not find both EN and PT versions.`);
+    }
+
+    // ✅ Ensure basic info is available before generating content
     if (
       !conceptEN.name ||
       !conceptEN.description ||
@@ -408,8 +438,8 @@ export class ConceptService {
 
     if (
       !override &&
-      conceptEN.content?.length > 0 &&
-      conceptPT.content?.length > 0
+      Array.isArray(conceptEN?.content) && conceptEN.content.length > 0 &&
+      Array.isArray(conceptPT?.content) && conceptPT.content.length > 0
     ) {
       console.log(`⚡ Content already exists for ${conceptSlug}, skipping.`);
       return; // ✅ Skip regeneration
@@ -432,7 +462,6 @@ export class ConceptService {
             combination: combinationString,
             name: conceptEN.name, // Use English name since both languages match in meaning
             description: conceptEN.description,
-            poem: conceptEN.poem,
           });
 
         // ✅ Call ChatGPT API
@@ -447,18 +476,39 @@ export class ConceptService {
 
         // ✅ Parse structured content for both languages
         const { structuredContentEN, structuredContentPT } =
-          this.parseStructuredContent(response);
+          this.parseStructuredContent(conceptSlug, response);
 
-        // 🌍 Store English content
-        Object.assign(conceptEN, { content: structuredContentEN });
-        await kvStore.put(kvKeyEN, JSON.stringify(conceptEN));
+        // ✅ Store content in D1
+        console.log(
+          `💾 Storing structured content for ${conceptSlug}:${combinationString} in D1...`
+        );
 
-        // 🇧🇷 Store Portuguese content
-        Object.assign(conceptPT, { content: structuredContentPT });
-        await kvStore.put(kvKeyPT, JSON.stringify(conceptPT));
+        await db.transaction(async (tx) => {
+          await tx
+            .update(conceptsData)
+            .set({ content: JSON.stringify(structuredContentEN) })
+            .where(
+              and(
+                eq(conceptsData.id, conceptEN.id),
+                eq(conceptsData.language, 'en-us')
+              )
+            )
+            .execute();
+
+          await tx
+            .update(conceptsData)
+            .set({ content: JSON.stringify(structuredContentPT) })
+            .where(
+              and(
+                eq(conceptsData.id, conceptPT.id),
+                eq(conceptsData.language, 'pt-br')
+              )
+            )
+            .execute();
+        });
 
         console.log(
-          `✅ Structured content stored for ${conceptSlug}, combination: ${combinationString}, in both languages.`
+          `✅ Structured content stored successfully for ${conceptSlug}:${combinationString}.`
         );
         return; // ✅ Exit loop if successful
       } catch (error) {
@@ -468,7 +518,9 @@ export class ConceptService {
         );
 
         // ✅ Store failure details in KV for manual review
-        await kvFailuresStore.put(
+        const failureKey = `failures:content:${conceptSlug}:${combinationString}`;
+
+        await this.context.kvConceptFailuresStore().put(
           failureKey,
           JSON.stringify({
             error: (error as Error).message,
@@ -495,11 +547,16 @@ export class ConceptService {
     }
   }
 
-  private parseStructuredContent(response: string): {
+  private parseStructuredContent(
+    conceptSlug: Concept,
+    response: string
+  ): {
     structuredContentEN: StructuredConceptContent;
     structuredContentPT: StructuredConceptContent;
   } {
-    console.log('📌 [START] Parsing structured content from ChatGPT response.');
+    console.log(
+      `📌 [START] Parsing structured content for ${conceptSlug} from ChatGPT response.`
+    );
 
     // ✅ Step 1: Clean artifacts before processing
     let cleanedResponse = response
@@ -513,23 +570,114 @@ export class ConceptService {
       cleanedResponse.slice(0, 500) + '...'
     );
 
-    const sectionsEN = [
-      'Core Identity',
-      'Strengths and Challenges',
-      'Path to Fulfillment',
-      'Emotional Depth',
-      'Vision and Aspirations',
-    ];
-
-    const sectionsPT = [
-      'Identidade Essencial',
-      'Forças e Desafios',
-      'Caminho para a Plenitude',
-      'Profundidade Emocional',
-      'Visão e Aspirações',
-    ];
-
-    // ✅ Step 2: Extract English and Portuguese content separately
+    // ✅ Step 2: Define Section Titles Per Concept
+    const conceptSections: Record<string, { en: string[]; pt: string[] }> = {
+      crown: {
+        en: [
+          'Core Identity',
+          'Strengths and Challenges',
+          'Path to Fulfillment',
+          'Emotional Depth',
+          'Vision and Aspirations',
+        ],
+        pt: [
+          'Identidade Essencial',
+          'Forças e Desafios',
+          'Caminho para a Plenitude',
+          'Profundidade Emocional',
+          'Visão e Aspirações',
+        ],
+      },
+      scepter: {
+        en: [
+          'The Power of Expression',
+          'The Dance of Action and Reaction',
+          'Navigating Challenges',
+          'The Mirror of Relationships',
+          'Impact on the World',
+        ],
+        pt: [
+          'O Poder da Expressão',
+          'A Dança da Ação e Reação',
+          'Navegando Desafios',
+          'O Espelho dos Relacionamentos',
+          'Impacto no Mundo',
+        ],
+      },
+      amulet: {
+        en: [
+          'The Shield of Protection',
+          'The Strength Within',
+          'Nurturing Growth',
+          'The Cycle of Renewal',
+          'The Anchor of Wisdom',
+        ],
+        pt: [
+          'O Escudo da Proteção',
+          'A Força Interior',
+          'Cultivando o Crescimento',
+          'O Ciclo da Renovação',
+          'A Âncora da Sabedoria',
+        ],
+      },
+      ring: {
+        en: [
+          'Magnetic Pull',
+          'Hidden Desires',
+          'The Fated Dance',
+          'Unveiling the Shadows',
+          'Your Love Power',
+        ],
+        pt: [
+          'Força Magnética',
+          'Desejos Ocultos',
+          'A Dança do Destino',
+          'Revelando as Sombras',
+          'Seu Poder no Amor',
+        ],
+      },
+      lantern: {
+        en: [
+          'The Call to Awakening',
+          'Walking Through Shadows',
+          'The Inner Flame',
+          'Revelations and Truths',
+          'Becoming the Light',
+        ],
+        pt: [
+          'O Chamado para o Despertar',
+          'Caminhando Pelas Sombras',
+          'A Chama Interior',
+          'Revelações e Verdades',
+          'Tornando-se a Luz',
+        ],
+      },
+      orb: {
+        en: [
+          'The Path Unfolding',
+          'A Calling Beyond the Self',
+          'Turning Points of Fate',
+          'Mastering the Journey',
+          'Legacy and Impact',
+        ],
+        pt: [
+          'O Caminho que se Revela',
+          'Um Chamado Além de Si Mesmo',
+          'Pontos de Virada do Destino',
+          'Dominando a Jornada',
+          'Legado e Impacto',
+        ],
+      },
+    };
+
+    const sectionsEN = conceptSections[conceptSlug]?.en;
+    const sectionsPT = conceptSections[conceptSlug]?.pt;
+
+    if (!sectionsEN || !sectionsPT) {
+      throw new Error(`❌ Unknown concept: ${conceptSlug}`);
+    }
+
+    // ✅ Step 3: Extract English and Portuguese content separately
     const enMatches = cleanedResponse.match(/EN:\s*([\s\S]+?)\s*PT:/);
     const ptMatches = cleanedResponse.match(/PT:\s*([\s\S]+)/);
 
@@ -552,7 +700,7 @@ export class ConceptService {
       ptContent.slice(0, 500) + '...'
     );
 
-    // ✅ Step 3: Extract structured sections
+    // ✅ Step 4: Extract structured sections
     function extractSections(text: string, sectionTitles: string[]) {
       return sectionTitles.map((title) => {
         console.log(`🔍 [PROCESSING] Extracting section: "${title}"`);

package/package.json

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

package/utils/buildMessages.ts

@@ -146,18 +146,15 @@ export const buildLLMMessages = (env: BackendBindings) => ({
   generateConceptContent: ({
     name,
     description,
-    poem,
     combination,
     conceptSlug,
   }: {
     name: string;
     description: string;
-    poem: string[];
     conceptSlug: Concept;
     combination: string;
   }): ChatMessages => {
     const zodiacCombination = mapConceptToPlanets(conceptSlug, combination);
-    const formattedPoem = poem.map((line) => `${line}`).join('\n');
 
     return [
       {
@@ -171,8 +168,6 @@ export const buildLLMMessages = (env: BackendBindings) => ({
           - Combination: ${zodiacCombination}
           - Name: ${name}
           - Description: ${description}
-          - Poem:
-          ${formattedPoem}
   
           Generate additional content to elaborate on this concept for frontend display.
         `,
@@ -246,7 +241,11 @@ export const buildLLMMessages = (env: BackendBindings) => ({
     ];
   },
 
-  translateENConceptName: ({ englishName }: { englishName: string }): ChatMessages => [
+  translateENConceptName: ({
+    englishName,
+  }: {
+    englishName: string;
+  }): ChatMessages => [
     {
       role: 'system',
       content: `