@zodic/shared 0.0.317 → 0.0.319

package/app/services/LeonardoService.ts

@@ -7,10 +7,6 @@ import { AppContext } from '../base/AppContext';
 
 interface QueueMessage {
   archetypeDataId: string;
-  combination: string;
-  gender: Gender;
-  language: string;
-  archetypeIndex: string;
 }
 
 @injectable()
@@ -53,39 +49,52 @@ export class LeonardoService {
    * Processes a message from ARCHETYPE_POPULATION_QUEUE to ensure the archetype has three images.
    */
   async processArchetypePopulation(message: QueueMessage): Promise<void> {
-    const { archetypeDataId, combination, gender, language, archetypeIndex } =
-      message;
+    const { archetypeDataId } = message;
     await this.log('info', 'Processing archetype population', {
       archetypeDataId,
-      combination,
-      gender,
-      language,
-      archetypeIndex,
     });
-
+  
     const db = this.context.drizzle();
     const archetype = await db
-      .select()
+      .select({
+        id: schema.archetypesData.id,
+        combination: schema.archetypesData.combination,
+        gender: schema.archetypesData.gender,
+        language: schema.archetypesData.language,
+        archetypeIndex: schema.archetypesData.archetypeIndex,
+        leonardoPrompt: schema.archetypesData.leonardoPrompt,
+        images: schema.archetypesData.images,
+      })
       .from(schema.archetypesData)
       .where(eq(schema.archetypesData.id, archetypeDataId))
       .limit(1)
       .execute();
-
+  
     if (!archetype[0]) {
       await this.log('error', 'Archetype not found', { archetypeDataId });
       throw new Error(`Archetype not found: ${archetypeDataId}`);
     }
-
-    const images = JSON.parse(archetype[0].images || '[]');
-    if (images.length >= 3) {
+  
+    const { combination, gender, language, archetypeIndex, leonardoPrompt, images } = archetype[0];
+  
+    await this.log('info', 'Fetched archetype details', {
+      archetypeDataId,
+      combination,
+      gender,
+      language,
+      archetypeIndex,
+    });
+  
+    const parsedImages = JSON.parse(images || '[]');
+    if (parsedImages.length >= 3) {
       await this.log('info', 'Archetype already has sufficient images', {
         archetypeDataId,
-        imageCount: images.length,
+        imageCount: parsedImages.length,
       });
       return;
     }
-
-    if (!archetype[0].leonardoPrompt) {
+  
+    if (!leonardoPrompt) {
       await this.log('error', 'Missing Leonardo prompt for archetype', {
         archetypeDataId,
       });
@@ -93,21 +102,21 @@ export class LeonardoService {
         `Missing Leonardo prompt for archetype: ${archetypeDataId}`
       );
     }
-
+  
     await this.log('debug', 'Generating images for archetype', {
       archetypeDataId,
-      prompt: archetype[0].leonardoPrompt,
+      prompt: leonardoPrompt,
     });
-
+  
     const generationResponse = await this.context
       .api()
       .callLeonardo.generateImage({
-        prompt: archetype[0].leonardoPrompt,
+        prompt: leonardoPrompt,
         width: 512,
         height: 640,
-        quantity: 3 - images.length,
+        quantity: 3 - parsedImages.length,
       });
-
+  
     const generationId = generationResponse.sdGenerationJob.generationId;
     if (!generationId) {
       await this.log(
@@ -117,7 +126,7 @@ export class LeonardoService {
       );
       throw new Error('Leonardo generation failed to return a valid ID');
     }
-
+  
     await db.insert(schema.generations).values({
       id: generationId,
       archetypeIndex: parseInt(archetypeIndex),
@@ -127,11 +136,11 @@ export class LeonardoService {
       gender,
       createdAt: new Date(),
     });
-
+  
     await this.log('info', 'Queued image generation', {
       generationId,
       archetypeDataId,
-      imagesToGenerate: 3 - images.length,
+      imagesToGenerate: 3 - parsedImages.length,
     });
   }
 

package/app/workflow/ArchetypeWorkflow.ts

@@ -1,4 +1,4 @@
-import { and, eq } from 'drizzle-orm';
+import { and, eq, inArray } from 'drizzle-orm';
 import { inject, injectable } from 'inversify';
 import { schema } from '../..';
 import { Gender } from '../../types';
@@ -55,7 +55,7 @@ export class ArchetypeWorkflow {
       gender,
       language,
     });
-
+  
     // Step 1: Check if archetypes exist, if not, generate names
     let archetypes = await this.archetypeService.fetchArchetypesFromDB(
       combinationString,
@@ -79,7 +79,7 @@ export class ArchetypeWorkflow {
       archetypesCount: archetypes.length,
       archetypeIds: archetypes.map((a) => a.id),
     });
-
+  
     // Step 2: Check if any archetypes are already being processed (images are generating)
     const db = this.context.drizzle();
     await this.log('debug', 'Checking for in-progress image generations', {
@@ -93,11 +93,14 @@ export class ArchetypeWorkflow {
         and(
           eq(schema.generations.status, 'pending'),
           eq(schema.generations.gender, gender),
-          eq(schema.generations.archetypeDataId, combinationString)
+          inArray(
+            schema.generations.archetypeDataId,
+            archetypes.map((a) => a.id)
+          )
         )
       )
       .execute();
-
+  
     if (inProgressGenerations.length > 0) {
       await this.log(
         'warn',
@@ -113,7 +116,7 @@ export class ArchetypeWorkflow {
       combinationString,
       gender,
     });
-
+  
     // Step 3: Generate missing textual content (description, virtues, content, leonardoPrompt)
     const archetypesNeedingText = archetypes.filter(
       (arc) =>
@@ -122,7 +125,7 @@ export class ArchetypeWorkflow {
         arc.content === '[]' ||
         !arc.leonardoPrompt
     );
-
+  
     if (archetypesNeedingText.length > 0) {
       await this.log('info', 'Generating missing textual content', {
         combinationString,
@@ -131,7 +134,7 @@ export class ArchetypeWorkflow {
         archetypesNeedingTextCount: archetypesNeedingText.length,
         archetypeIds: archetypesNeedingText.map((a) => a.id),
       });
-
+  
       const descVirtues =
         await this.archetypeService.generateDescriptionsAndVirtues(
           combinationString,
@@ -157,7 +160,7 @@ export class ArchetypeWorkflow {
         language,
       });
     }
-
+  
     // Refetch archetypes after generating textual content
     const updatedArchetypes = await this.archetypeService.fetchArchetypesFromDB(
       combinationString,
@@ -168,12 +171,12 @@ export class ArchetypeWorkflow {
       updatedArchetypesCount: updatedArchetypes.length,
       archetypeIds: updatedArchetypes.map((a) => a.id),
     });
-
+  
     // Step 4: Queue image generation if needed
     const archetypesNeedingImages = updatedArchetypes.filter(
       (arc) => JSON.parse(arc.images).length < 3
     );
-
+  
     if (archetypesNeedingImages.length > 0) {
       await this.log(
         'info',
@@ -183,14 +186,10 @@ export class ArchetypeWorkflow {
           archetypeIds: archetypesNeedingImages.map((a) => a.id),
         }
       );
-
+  
       const batch = archetypesNeedingImages.map((arc) => ({
         body: {
           archetypeDataId: arc.id,
-          combination: combinationString,
-          gender,
-          language,
-          archetypeIndex: arc.archetypeIndex,
         },
       }));
       await this.log('debug', 'Sending batch to ARCHETYPE_POPULATION_QUEUE', {
@@ -201,10 +200,10 @@ export class ArchetypeWorkflow {
       await this.log('info', 'Successfully queued image generation', {
         batchCount: batch.length,
       });
-
+  
       return { message: 'Images are being processed, please try again later.' };
     }
-
+  
     await this.log('info', 'Archetypes fully processed and ready', {
       updatedArchetypes,
     });

package/package.json

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