@zodic/shared 0.0.87 → 0.0.88

package/app/services/ConceptService.ts

@@ -1,5 +1,8 @@
+import { and, eq } from 'drizzle-orm';
 import { inject, injectable } from 'inversify';
 import 'reflect-metadata';
+import { v4 as uuidv4 } from 'uuid';
+import { schema } from '../..';
 import { Languages } from '../../types';
 import { KVConcept, sizes } from '../../types/scopes/legacy';
 import { buildConceptKVKey } from '../../utils/KVKeysBuilders';
@@ -155,31 +158,131 @@ export class ConceptService {
     conceptSlug: string,
     combinationString: string
   ): Promise<void> {
+    const drizzle = this.context.drizzle();
+    const { width, height } = sizes['alchemy']['post4:5'];
+    const { generations, conceptCombinations, concepts } = schema;
+
     const kvKey = buildConceptKVKey(language, conceptSlug, combinationString);
     console.log(
-      `Queuing image generation for concept: ${conceptSlug}, combination: ${combinationString}, language: ${language}`
+      `🚀 Queuing image generation for concept: ${conceptSlug}, combination: ${combinationString}, language: ${language}`
     );
 
     const concept = await this.getKVConcept(kvKey);
     if (!concept.leonardoPrompt) {
       throw new Error(
-        `Leonardo prompt must be populated before generating images for concept: ${conceptSlug}`
+        `❌ Leonardo prompt must be populated before generating images for concept: ${conceptSlug}`
       );
     }
 
-    const { width, height } = sizes['alchemy']['post4:5'];
+    // 🔍 Fetch Concept ID using conceptSlug
+    const conceptRecord = await drizzle
+      .select({
+        id: concepts.id,
+        planet1: concepts.planet1,
+        planet2: concepts.planet2,
+        planet3: concepts.planet3,
+      })
+      .from(concepts)
+      .where(eq(concepts.slug, conceptSlug))
+      .limit(1);
+
+    if (conceptRecord.length === 0) {
+      throw new Error(`❌ No concept found for slug: ${conceptSlug}`);
+    }
+
+    const { id: conceptId, planet1, planet2, planet3 } = conceptRecord[0];
+    console.log(
+      `✅ Retrieved conceptId: ${conceptId} for slug: ${conceptSlug}`
+    );
+
+    const [planet1Sign, planet2Sign, planet3Sign] =
+      combinationString.split('-');
+
+    if (!planet1Sign || !planet2Sign || (planet3 && !planet3Sign)) {
+      throw new Error(
+        `❌ Invalid combinationString: ${combinationString} (Expected format: sign1-sign2-[sign3])`
+      );
+    }
+
+    console.log(
+      `🌌 Extracted planet signs: ${planet1} -> ${planet1Sign}, ${planet2} -> ${planet2Sign}, ${
+        planet3 || 'N/A'
+      } -> ${planet3Sign || 'N/A'}`
+    );
+
+    // 🔍 Ensure Concept Combination exists
+    let [conceptCombination] = await drizzle
+      .select({ id: conceptCombinations.id })
+      .from(conceptCombinations)
+      .where(
+        and(
+          eq(conceptCombinations.combinationString, combinationString),
+          eq(conceptCombinations.conceptId, conceptId)
+        )
+      )
+      .limit(1);
+
+    if (!conceptCombination) {
+      console.log(
+        `🔍 No existing conceptCombination found. Creating new entry for ${conceptSlug}:${combinationString}`
+      );
+
+      const [insertedCombination] = await drizzle
+        .insert(conceptCombinations)
+        .values({
+          id: uuidv4(),
+          combinationString,
+          conceptId,
+          planet1Sign,
+          planet2Sign,
+          planet3Sign, // Ensure null if planet3 is not used
+        })
+        .returning({ id: conceptCombinations.id });
+
+      conceptCombination = insertedCombination;
+    }
+
+    const conceptCombinationId = conceptCombination.id;
+    console.log(
+      `✅ Using conceptCombinationId: ${conceptCombinationId} for ${conceptSlug}:${combinationString}`
+    );
+
+    // 🎨 Request Leonardo AI image generation
+    console.log(`🎨 Requesting Leonardo AI image generation...`);
+    const leonardoResponse = await this.context
+      .api()
+      .callLeonardo.generateImage({
+        prompt: concept.leonardoPrompt,
+        width,
+        height,
+      });
 
-    await this.context.api().callLeonardo.generateImage({
-      prompt: concept.leonardoPrompt,
-      width,
-      height,
+    const generationId = leonardoResponse?.sdGenerationJob?.generationId;
+    if (!generationId) {
+      throw new Error(
+        `❌ Failed to retrieve generationId from Leonardo response`
+      );
+    }
+
+    console.log(`✅ Leonardo Generation ID received: ${generationId}`);
+
+    // 📝 Insert Generation Record with the received generationId
+    await drizzle.insert(generations).values({
+      id: generationId, // Use the ID from Leonardo
+      conceptCombinationId,
+      type: 'concept_image',
+      status: 'pending',
+      createdAt: new Date(),
     });
 
     console.log(
-      `Post images queued for concept: ${conceptSlug}, combination: ${combinationString}, language: ${language}`
+      `📝 Generation record created: ${generationId} for ${conceptSlug}:${combinationString}`
     );
-  }
 
+    console.log(
+      `🎨 Leonardo AI image generation triggered for ${conceptSlug}:${combinationString}, tracking ID: ${generationId}`
+    );
+  }
   /**
    * Fetch and initialize a KVConcept object if not present.
    */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zodic/shared",
-  "version": "0.0.87",
+  "version": "0.0.88",
   "module": "index.ts",
   "type": "module",
   "publishConfig": {
@@ -32,6 +32,7 @@
     "inversify": "^6.2.1",
     "jose": "^5.9.6",
     "openai": "^4.81.0",
-    "reflect-metadata": "^0.2.2"
+    "reflect-metadata": "^0.2.2",
+    "uuid": "^11.0.5"
   }
 }

package/utils/mapConceptToPlanets.ts

@@ -1,25 +1,28 @@
-export const mapConceptToPlanets = (conceptSlug: string, combination: string): string => {
+export const mapConceptToPlanets = (
+  conceptSlug: string,
+  combination: string
+): string => {
   const signs = combination.split('-');
 
   const conceptPlanetMapping: Record<string, string[]> = {
     crown: ['Sun', 'Ascendant', 'Moon'],
     scepter: ['Mercury', 'Venus', 'Mars'],
     amulet: ['Jupiter', 'Saturn', 'Chiron'],
-    lantern: ['Uranus', 'Pluto', 'Neptune'],
+    lantern: ['Uranus', 'Neptune', 'Pluto'],
     orb: ['North Node', 'Midheaven', 'Pars Fortuna'],
   };
 
   const planets = conceptPlanetMapping[conceptSlug];
-  
+
   if (!planets) {
     throw new Error(`Invalid conceptSlug provided: ${conceptSlug}`);
   }
 
   if (signs.length !== planets.length) {
-    throw new Error(`Combination does not match the expected number of planets for concept: ${conceptSlug}`);
+    throw new Error(
+      `Combination does not match the expected number of planets for concept: ${conceptSlug}`
+    );
   }
 
-  return signs
-    .map((sign, index) => `- ${planets[index]}: ${sign}`)
-    .join('\n');
-};
+  return signs.map((sign, index) => `- ${planets[index]}: ${sign}`).join('\n');
+};