@zodic/shared 0.0.153 → 0.0.154

package/app/api/index.ts

@@ -38,7 +38,7 @@ export const Api = (env: BackendBindings) => ({
   callTogether: {
     single: async (
       messages: ChatMessages,
-      { model = 'deepseek-ai/DeepSeek-V3', options = { } }: DeepSeekOptions
+      { model = 'deepseek-ai/DeepSeek-V3', options = {} }: DeepSeekOptions
     ): Promise<string> => {
       try {
         const response = await together(env).chat.completions.create({

package/app/workflow/ConceptWorkflow.ts

@@ -1,4 +1,6 @@
 import { inject, injectable } from 'inversify';
+import pMap from 'p-map';
+import { zodiacSignCombinations } from '../../data/zodiacSignCombinations';
 import { Concept, ConceptPhase } from '../../types';
 import { ConceptService } from '../services/ConceptService';
 
@@ -13,7 +15,7 @@ export class ConceptWorkflow {
     override?: boolean
   ) {
     console.log(
-      `Processing single concept for slug: ${conceptSlug}, combination: ${combinationString}, phase: ${phase}`
+      `🚀 Processing single concept: ${conceptSlug} | ${combinationString} | Phase: ${phase}`
     );
 
     try {
@@ -50,14 +52,73 @@ export class ConceptWorkflow {
       }
 
       console.log(
-        `Concept ${conceptSlug}:${combinationString} successfully processed for phase: ${phase}`
+        `✅ Concept ${conceptSlug}:${combinationString} successfully processed for phase: ${phase}`
       );
     } catch (error) {
       console.error(
-        `Error processing concept ${conceptSlug}:${combinationString} for phase ${phase}:`,
+        `❌ Error processing concept ${conceptSlug}:${combinationString} | Phase: ${phase}:`,
         error
       );
-      throw error;
     }
   }
+
+  async processBatch(
+    conceptSlug: Concept,
+    combinations: string[],
+    phase: ConceptPhase,
+    override?: boolean
+  ) {
+    console.log(
+      `🚀 Processing batch for concept: ${conceptSlug}, Phase: ${phase}, Total Combinations: ${combinations.length}`
+    );
+
+    const concurrency = 20; // Adjust based on response speed
+    const failedCombinations: string[] = [];
+
+    await pMap(
+      combinations,
+      async (combination) => {
+        try {
+          await this.processSingle(conceptSlug, combination, phase, override);
+        } catch (error) {
+          console.error(`❌ Error processing ${combination}:`, error);
+          failedCombinations.push(combination); // Store failed ones
+        }
+      },
+      { concurrency }
+    );
+
+    if (failedCombinations.length > 0) {
+      console.warn(`⚠️ Retrying failed combinations:`, failedCombinations);
+      await this.processBatch(conceptSlug, failedCombinations, phase, override); // Retry
+    }
+    console.log(
+      `✅ Batch processing completed for concept: ${conceptSlug}, Phase: ${phase}`
+    );
+  }
+
+  async processAllCombinations(
+    conceptSlug: Concept,
+    phase: ConceptPhase,
+    override?: boolean
+  ) {
+    console.log(`🔍 Fetching all possible combinations for: ${conceptSlug}`);
+
+    // 🔥 Replace with the actual function that retrieves all pre-defined combinations from KV or DB
+    const combinations = zodiacSignCombinations;
+    if (!combinations.length) {
+      console.warn(`⚠️ No combinations found for ${conceptSlug}, skipping.`);
+      return;
+    }
+
+    console.log(
+      `🚀 Processing ALL combinations for ${conceptSlug}, Phase: ${phase}, Total: ${combinations.length}`
+    );
+
+    await this.processBatch(conceptSlug, combinations, phase, override);
+
+    console.log(
+      `✅ All combinations processed for concept: ${conceptSlug}, Phase: ${phase}`
+    );
+  }
 }