@zodic/shared 0.0.400 → 0.0.402

package/app/api/index.ts

@@ -448,105 +448,6 @@ export const Api = (env: BackendBindings) => ({
       }
     },
   },
-  callImageDescriber: async (imageUrl: string): Promise<string> => {
-    const mimeType = 'image/png';
-    const endpoint =
-      'https://us-central1-describepicture.cloudfunctions.net/describe_picture_api';
-    const hexKey = env.DESCRIBER_API_KEY;
-    if (!hexKey) throw new Error('Describer API Key not found');
-
-    const appId = env.DESCRIBER_APP_ID;
-    if (!appId) throw new Error('Describer APP ID not found');
-
-    const data = JSON.stringify({
-      imageUrl,
-      prompt: env.PROMPT_IMAGE_DESCRIBER,
-      mimeType,
-      appId,
-      imageBase64: '',
-    });
-
-    const encryptData = async (
-      data: string,
-      hexKey: string
-    ): Promise<{ iv: string; encryptedData: string }> => {
-      const keyBytes = Uint8Array.from(
-        hexKey.match(/.{2}/g)?.map((byte) => parseInt(byte, 16)) || []
-      );
-
-      const key = await crypto.subtle.importKey(
-        'raw',
-        keyBytes,
-        { name: 'AES-GCM' },
-        false,
-        ['encrypt']
-      );
-
-      const iv = crypto.getRandomValues(new Uint8Array(12));
-      const encodedData = new TextEncoder().encode(data);
-
-      const encrypted = await crypto.subtle.encrypt(
-        { name: 'AES-GCM', iv },
-        key,
-        encodedData
-      );
-
-      return {
-        iv: btoa(String.fromCharCode(...iv)),
-        encryptedData: btoa(String.fromCharCode(...new Uint8Array(encrypted))),
-      };
-    };
-
-    const { iv, encryptedData } = await encryptData(data, hexKey);
-
-    const payload = { iv, encryptedData };
-
-    try {
-      const response = await fetch(endpoint, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify(payload),
-      });
-
-      if (!response.ok) {
-        const error = await response.json();
-        console.error('Error from Image Describer API:', error);
-        throw new Error(`Image Describer API Error: ${response.status}`);
-      }
-
-      const result = (await response.json()) as string;
-      return result;
-    } catch (err: any) {
-      console.error('Error calling Image Describer API:', err.message);
-      throw err;
-    }
-  },
-
-  callUForm: async (imageUrl: string): Promise<string> => {
-    try {
-      const res = await fetch(imageUrl);
-      console.log('IMAGE URL -> ', imageUrl);
-      const blob = await res.arrayBuffer();
-
-      const input = {
-        image: [...new Uint8Array(blob)],
-        prompt: env.PROMPT_IMAGE_DESCRIBER,
-        max_tokens: 512,
-      };
-
-      const response = await env.AI.run('@cf/llava-hf/llava-1.5-7b-hf', input);
-
-      if (!response) {
-        throw new Error('UForm model did not return a response.');
-      }
-
-      console.log('UForm Model Response ->', response.description);
-      return response.description;
-    } catch (err: any) {
-      console.error('Error using UForm model:', err.message);
-      throw err;
-    }
-  },
 
   callAstrology: {
     getNatalChartInterpretation: async ({

package/app/base/AppContext.ts

@@ -13,31 +13,6 @@ export class AppContext {
     return buildLLMMessages(this.env);
   }
 
-  kvCosmicMirrorArchetypesStore() {
-    if (!this.env.KV_COSMIC_MIRROR_ARCHETYPES) {
-      throw new Error(
-        'KV_COSMIC_MIRROR_ARCHETYPES is not defined in the environment.'
-      );
-    }
-    return this.env.KV_COSMIC_MIRROR_ARCHETYPES;
-  }
-
-  kvCosmicMirrorManagementStore() {
-    if (!this.env.KV_COSMIC_MIRROR_MANAGEMENT) {
-      throw new Error(
-        'KV_COSMIC_MIRROR_MANAGEMENT is not defined in the environment.'
-      );
-    }
-    return this.env.KV_COSMIC_MIRROR_MANAGEMENT;
-  }
-
-  kvConceptsStore() {
-    if (!this.env.KV_CONCEPTS) {
-      throw new Error('KV_CONCEPTS is not defined in the environment.');
-    }
-    return this.env.KV_CONCEPTS;
-  }
-
   kvConceptFailuresStore() {
     if (!this.env.KV_CONCEPT_FAILURES) {
       throw new Error('KV_CONCEPT_FAILURES is not defined in the environment.');
@@ -45,22 +20,6 @@ export class AppContext {
     return this.env.KV_CONCEPT_FAILURES;
   }
 
-  kvConceptNamesStore() {
-    if (!this.env.KV_CONCEPT_NAMES) {
-      throw new Error('KV_CONCEPT_NAMES is not defined in the environment.');
-    }
-    return this.env.KV_CONCEPT_NAMES;
-  }
-
-  kvConceptsManagementStore() {
-    if (!this.env.KV_CONCEPTS_MANAGEMENT) {
-      throw new Error(
-        'KV_CONCEPTS_MANAGEMENT is not defined in the environment.'
-      );
-    }
-    return this.env.KV_CONCEPTS_MANAGEMENT;
-  }
-
   kvAstroStore() {
     if (!this.env.KV_ASTRO) {
       throw new Error('KV_ASTRO is not defined in the environment.');

package/app/services/ConceptService.ts

@@ -2,7 +2,7 @@ import {
   KVNamespaceListKey,
   KVNamespaceListResult,
 } from '@cloudflare/workers-types';
-import { and, eq, inArray, isNull } from 'drizzle-orm';
+import { and, eq, inArray, isNull, sql } from 'drizzle-orm';
 import { drizzle } from 'drizzle-orm/d1';
 import { inject, injectable } from 'inversify';
 import 'reflect-metadata';
@@ -16,6 +16,7 @@ import {
   concepts,
   conceptsData,
   houseReports,
+  users,
 } from '../../db/schema';
 import {
   AstrologicalReport,
@@ -44,6 +45,7 @@ export class ConceptService {
     const drizzle = this.context.drizzle();
     const conceptsList = await drizzle
       .select({
+        id: concepts.id,
         slug: concepts.slug,
         planet1: concepts.planet1,
         planet2: concepts.planet2,
@@ -58,156 +60,6 @@ export class ConceptService {
   /**
    * Generate basic info for a concept: name, description, and poem.
    */
-  async generateBasicInfo(
-    conceptSlug: Concept,
-    combinationString: string,
-    override: boolean = false
-  ): Promise<void> {
-    console.log(
-      `🚀 Generating basic info for concept: ${conceptSlug}, combination: ${combinationString}, override: ${override}`
-    );
-
-    const kvStore = this.context.kvConceptsStore();
-    const kvFailuresStore = this.context.kvConceptFailuresStore();
-    const kvKeyEN = buildConceptKVKey('en-us', conceptSlug, combinationString);
-    const kvKeyPT = buildConceptKVKey('pt-br', conceptSlug, combinationString);
-
-    // ✅ Use Durable Object stub
-    const id = this.context.env.CONCEPT_NAMES_DO.idFromName(conceptSlug);
-    const stub = this.context.env.CONCEPT_NAMES_DO.get(id);
-
-    console.log(`📡 Fetching existing KV data for ${conceptSlug}...`);
-    const existingEN = await this.getKVConcept(kvKeyEN);
-    const existingPT = await this.getKVConcept(kvKeyPT);
-
-    if (!override && existingEN.name && existingPT.name) {
-      console.log(`⚡ Basic info already exists for ${conceptSlug}, skipping.`);
-      return;
-    }
-
-    let attempts = 0;
-    const maxAttempts = 3;
-    const MAX_NAME_LENGTH = 44;
-
-    while (attempts < maxAttempts) {
-      let phase = 'generation';
-      try {
-        attempts++;
-        console.log(
-          `🔄 Attempt ${attempts} to generate basic info for ${conceptSlug}...`
-        );
-
-        let allNamesEN: string[] = [];
-        let allNamesPT: string[] = [];
-        const response = await stub.fetch(`https://internal/names`);
-
-        if (response.ok) {
-          const data = (await response.json()) as {
-            'en-us': string[];
-            'pt-br': string[];
-          };
-          allNamesEN = data['en-us'] || [];
-          allNamesPT = data['pt-br'] || [];
-        }
-
-        console.log(`✏️ Generating new name...`);
-        const messages = this.context
-          .buildLLMMessages()
-          .generateConceptBasicInfo({
-            combination: combinationString,
-            conceptSlug,
-            existingNames:
-              allNamesEN.length > 100 ? allNamesEN.slice(-100) : allNamesEN,
-          });
-
-        let aiResponse = await this.context
-          .api()
-          .callTogether.single(messages, {});
-        if (!aiResponse) throw new Error(`❌ AI returned an empty response`);
-
-        phase = 'cleaning';
-        aiResponse = this.cleanAIResponse(aiResponse);
-
-        console.log('!-- aiResponse -> ', aiResponse);
-        console.log('!-- aiResponse length -> ', aiResponse.length);
-
-        phase = 'parsing';
-        let { nameEN, descriptionEN, poemEN, namePT, descriptionPT, poemPT } =
-          this.parseBasicInfoResponse(aiResponse, conceptSlug);
-
-        console.log(`🎭 Generated names: EN - "${nameEN}", PT - "${namePT}"`);
-
-        // ✅ Forcefully trim the name to exactly 5 words if it's too long
-        const enforceWordLimit = (name: string): string => {
-          const words = name.split(/\s+/);
-          if (words.length > 6) {
-            return words.slice(0, 6).join(' ');
-          }
-          return name;
-        };
-
-        nameEN = enforceWordLimit(nameEN);
-        namePT = enforceWordLimit(namePT);
-
-        console.log(`✂️ Trimmed names: EN - "${nameEN}", PT - "${namePT}"`);
-
-        // ✅ Check uniqueness before storing
-        if (allNamesEN.includes(nameEN) || allNamesPT.includes(namePT)) {
-          console.warn(
-            `⚠️ Duplicate Name Detected: "${nameEN}" or "${namePT}"`
-          );
-          if (attempts >= maxAttempts) {
-            console.log(
-              `🚨 Max attempts reached. Storing name despite duplicate.`
-            );
-            await kvFailuresStore.put(
-              `failures:duplicates:${conceptSlug}:${combinationString}`,
-              JSON.stringify({
-                nameEN,
-                namePT,
-                attempts,
-                conceptSlug,
-                combinationString,
-                timestamp: new Date().toISOString(),
-              })
-            );
-            break;
-          }
-          continue;
-        }
-
-        console.log(`📝 Storing names in Durable Object...`);
-        // await stub.fetch(`https://internal/add-name`, { method: 'POST', body: JSON.stringify({ language: 'en-us', name: nameEN }), headers: { 'Content-Type': 'application/json' } });
-        // await stub.fetch(`https://internal/add-name`, { method: 'POST', body: JSON.stringify({ language: 'pt-br', name: namePT }), headers: { 'Content-Type': 'application/json' } });
-
-        Object.assign(existingEN, {
-          name: nameEN,
-          description: descriptionEN,
-          poem: poemEN,
-          status: 'idle',
-        });
-        await kvStore.put(kvKeyEN, JSON.stringify(existingEN));
-
-        Object.assign(existingPT, {
-          name: namePT,
-          description: descriptionPT,
-          poem: poemPT,
-          status: 'idle',
-        });
-        await kvStore.put(kvKeyPT, JSON.stringify(existingPT));
-
-        console.log(
-          `✅ Stored basic info for ${conceptSlug}, combination: ${combinationString}.`
-        );
-        return;
-      } catch (error) {
-        console.error(
-          `❌ Attempt ${attempts} failed at phase: ${phase}`,
-          error
-        );
-      }
-    }
-  }
 
   private cleanAIResponse(response: string): string {
     console.log('🧼 Cleaning AI Response...');
@@ -1049,99 +901,7 @@ export class ConceptService {
   /**
    * Fetch and initialize a KVConcept object if not present.
    */
-  private async getKVConcept(kvKey: string): Promise<KVConcept> {
-    const existingData = await this.context
-      .kvConceptsStore()
-      .get<KVConcept>(kvKey, 'json');
-
-    if (existingData) {
-      return existingData;
-    }
-
-    console.log(
-      `No existing KV data found. Creating default entry for key: ${kvKey}`
-    );
-    return {
-      name: '',
-      description: '',
-      content: [],
-      poem: [],
-      leonardoPrompt: '',
-      postImages: [],
-      reelImages: [null, null, null],
-      status: 'idle',
-    };
-  }
-
-  private async findDuplicateNamesAndUsedNames(limit?: number) {
-    console.log(`🔍 Scanning KV for duplicate names...`);
-
-    const kvStore = this.context.env.KV_CONCEPTS;
-    let cursor: string | undefined = undefined;
-    let nameUsageMapEN: Record<string, string[]> = {}; // { enName: [combination1, combination2] }
-    let usedNamesEN = new Set<string>(); // ✅ All used EN names
-    let usedNamesPT = new Set<string>(); // ✅ All used PT names
-    let totalKeysScanned = 0;
-
-    do {
-      const response: KVNamespaceListResult<KVConcept> = (await kvStore.list({
-        prefix: 'concepts:',
-        cursor,
-      })) as KVNamespaceListResult<KVConcept, string>;
-
-      const {
-        keys,
-        cursor: newCursor,
-      }: { keys: KVNamespaceListKey<KVConcept>[]; cursor?: string } = response;
-
-      totalKeysScanned += keys.length;
-
-      for (const key of keys) {
-        const kvData = (await kvStore.get(key.name, 'json')) as {
-          name: string;
-          ptName?: string;
-        };
-
-        if (kvData?.name) {
-          usedNamesEN.add(kvData.name); // ✅ Store all used EN names
-
-          if (!nameUsageMapEN[kvData.name]) {
-            nameUsageMapEN[kvData.name] = [];
-          }
-          nameUsageMapEN[kvData.name].push(key.name); // Store the key for that name
-        }
-
-        if (kvData?.ptName) {
-          usedNamesPT.add(kvData.ptName); // ✅ Store all used PT names
-        }
-      }
 
-      cursor = newCursor;
-    } while (cursor && (!limit || totalKeysScanned < limit));
-
-    // ✅ Find names used more than once (EN)
-    let duplicateENNames = Object.entries(nameUsageMapEN)
-      .filter(([_, combinations]) => combinations.length > 1)
-      .map(([name, combinations]) => ({
-        name,
-        combinations,
-      }));
-
-    // ✅ If limit is set, trim duplicates list
-    if (limit && duplicateENNames.length > limit) {
-      duplicateENNames = duplicateENNames.slice(0, limit);
-    }
-
-    console.log(
-      `✅ Found ${duplicateENNames.length} duplicate EN names out of ${totalKeysScanned} entries.`
-    );
-
-    return {
-      duplicateEntries: duplicateENNames, // ✅ List of EN names that need regeneration
-      usedNamesEN, // ✅ Set of all unique EN names
-      usedNamesPT, // ✅ Set of all unique PT names
-    };
-  }
 
   async generateAstroReportContent(
     params:
@@ -1831,7 +1591,7 @@ export class ConceptService {
     );
   }
 
-  // src/services/ConceptService.ts
+  // src/services/ts
   async checkConceptCompletion(
     conceptSlug: Concept,
     combinationString: string,
@@ -1866,4 +1626,172 @@ export class ConceptService {
 
     return hasPrompt && !!hasPostImages;
   }
+
+  async getLang(userId: string): Promise<'pt-br' | 'en-us'> {
+    try {
+      console.log(
+        `🌍 [LANG QUERY] Fetching language preference for user: ${userId}`
+      );
+
+      const drizzle = this.context.drizzle();
+      const user = await drizzle
+        .select({ language: users.language })
+        .from(users)
+        .where(eq(users.id, userId))
+        .get();
+
+      if (!user || !user.language) {
+        console.warn(
+          `⚠️ [LANG WARNING] No language preference found for user: ${userId}, defaulting to 'pt-br'`
+        );
+        return 'pt-br';
+      }
+
+      console.log(
+        `✅ [LANG SUCCESS] Retrieved language for user: ${userId} -> ${user.language}`
+      );
+      return user.language as 'pt-br' | 'en-us';
+    } catch (error) {
+      console.error(
+        `❌ [ERROR] Failed to fetch language for user ${userId}:`,
+        error
+      );
+      throw new Error('Failed to fetch user language');
+    }
+  }
+
+  async queueUserConcepts(userId: string): Promise<void> {
+    console.log(
+      `[${new Date().toISOString()}] 🔧 Starting queueing of user concepts for user ${userId}`
+    );
+
+    const lang = await this.getLang(userId);
+    console.log(
+      `[${new Date().toISOString()}] 📝 Retrieved language for user ${userId}: ${lang}`
+    );
+
+    const db = this.context.drizzle();
+    const { userConcepts } = schema;
+
+    // Fetch all available concepts
+    const concepts = await this.getAllConcepts();
+    if (!concepts || concepts.length === 0) {
+      console.log(
+        `[${new Date().toISOString()}] ⚠️ No concepts found to queue for user ${userId}`
+      );
+      return;
+    }
+    console.log(
+      `[${new Date().toISOString()}] ✅ Retrieved ${
+        concepts.length
+      } concepts for user ${userId}`
+    );
+
+    for (const concept of concepts) {
+      const {
+        id: conceptId,
+        slug: conceptSlug,
+        planet1,
+        planet2,
+        planet3,
+      } = concept;
+
+      console.log(
+        `[${new Date().toISOString()}] 🔧 Processing concept ${conceptSlug} for user ${userId}`
+      );
+
+      const planets = [planet1, planet2, planet3];
+      const userSigns = await this.getUserSigns(userId, planets);
+      if (userSigns.length !== 3) {
+        console.log(
+          `[${new Date().toISOString()}] ⚠️ Missing astrological data for user ${userId} in concept ${conceptSlug}, found ${
+            userSigns.length
+          } signs`
+        );
+        continue; // Skip to the next concept if signs are missing
+      }
+      console.log(
+        `[${new Date().toISOString()}] ✅ Retrieved user signs for ${conceptSlug}: ${userSigns
+          .map((s) => `${s.name}: ${s.sign}`)
+          .join(', ')}`
+      );
+
+      const signMap = new Map(userSigns.map((s) => [s.name, s.sign]));
+      const combinationString = [
+        signMap.get(planet1),
+        signMap.get(planet2),
+        signMap.get(planet3),
+      ].join('-');
+      console.log(
+        `[${new Date().toISOString()}] 🔗 Generated combination string for ${conceptSlug}: ${combinationString}`
+      );
+
+      // Create or retrieve conceptCombination
+      const conceptCombinationId = await this.getOrCreateConceptCombination(
+        conceptId,
+        combinationString,
+        planets,
+        userSigns
+      );
+      console.log(
+        `[${new Date().toISOString()}] ✅ Created/Retrieved concept combination ID for ${conceptSlug}: ${conceptCombinationId}`
+      );
+
+      // Check if a userConcept exists; create if not
+      const existingUserConcept = await db
+        .select({ conceptCombinationId: userConcepts.conceptCombinationId })
+        .from(userConcepts)
+        .where(
+          and(
+            eq(userConcepts.userId, userId),
+            eq(userConcepts.conceptId, conceptId)
+          )
+        )
+        .limit(1)
+        .execute();
+
+      if (!existingUserConcept.length) {
+        const userConceptId = uuidv4();
+        await db
+          .insert(userConcepts)
+          .values({
+            id: userConceptId,
+            userId,
+            conceptId,
+            conceptCombinationId,
+            createdAt: sql`CURRENT_TIMESTAMP`,
+            updatedAt: sql`CURRENT_TIMESTAMP`,
+          })
+          .execute();
+        console.log(
+          `[${new Date().toISOString()}] ✅ Inserted new user concept with ID: ${userConceptId} for ${conceptSlug}`
+        );
+      } else {
+        console.log(
+          `[${new Date().toISOString()}] 🔍 Found existing user concept for user ${userId}, concept ${conceptSlug}`
+        );
+      }
+
+      // Queue the generation
+      const queuePayload = {
+        userId,
+        conceptSlug,
+        combinationString,
+        lang,
+        conceptCombinationId,
+      };
+      console.log(
+        `[${new Date().toISOString()}] ✅ Queue Payload for ${conceptSlug}:`,
+        queuePayload
+      );
+      await this.context.env.CONCEPT_GENERATION_QUEUE.send(queuePayload);
+      console.log(
+        `[${new Date().toISOString()}] ⏳ Queued concept generation for ${conceptSlug}:${combinationString}`
+      );
+    }
+
+    console.log(
+      `[${new Date().toISOString()}] ✅ Completed queueing all concepts for user ${userId}`
+    );
+  }
 }

package/app/services/PaymentService.ts

@@ -1,11 +1,15 @@
 import { eq } from 'drizzle-orm';
 import { injectable } from 'inversify';
+import { payments, products, userProducts } from '../../db/schema';
 import { AppContext } from '../base';
-import { payments, userProducts } from '../../db/schema';
+import { ConceptService } from './ConceptService';
 
 @injectable()
 export class PaymentService {
-  constructor(private context: AppContext) {}
+  constructor(
+    private context: AppContext,
+    private conceptService: ConceptService
+  ) {}
 
   async handleCheckoutEvent(payload: any): Promise<void> {
     const { event, checkout } = payload;
@@ -57,6 +61,60 @@ export class PaymentService {
   private async handleCheckoutPaid(checkout: any): Promise<void> {
     const checkoutId = checkout.id;
     const db = this.context.drizzle();
+
+    // Fetch the userProduct to get userId and productId
+    const userProduct = await db
+      .select({
+        userId: userProducts.userId,
+        productId: userProducts.productId,
+      })
+      .from(userProducts)
+      .where(eq(userProducts.checkoutId, checkoutId))
+      .limit(1)
+      .get();
+
+    if (!userProduct) {
+      console.log(
+        `[${new Date().toISOString()}] ⚠️ No user product found for checkoutId: ${checkoutId}`
+      );
+      return;
+    }
+
+    // Fetch the product slug
+    const product = await db
+      .select({ slug: products.slug })
+      .from(products)
+      .where(eq(products.id, userProduct.productId))
+      .limit(1)
+      .get();
+
+    if (!product) {
+      console.log(
+        `[${new Date().toISOString()}] ⚠️ No product found for productId: ${
+          userProduct.productId
+        }`
+      );
+      return;
+    }
+
+    // Queue concept generations if the product slug is "concepts"
+    if (product.slug === 'concepts') {
+      try {
+        await this.conceptService.queueUserConcepts(userProduct.userId);
+        console.log(
+          `[${new Date().toISOString()}] ⏳ Queued concept generations for user ${
+            userProduct.userId
+          } after successful payment`
+        );
+      } catch {
+        console.log(
+          `[${new Date().toISOString()}] ⚠️  Error queuing concept generations for user ${
+            userProduct.userId
+          } after successful payment`
+        );
+      }
+    }
+
     // Update userProducts to 'unlocked'
     await db
       .update(userProducts)
@@ -78,6 +136,7 @@ export class PaymentService {
     const checkoutId = checkout.id;
     const db = this.context.drizzle();
     // Update userProducts to 'locked'
+
     await db
       .update(userProducts)
       .set({ status: 'locked', updatedAt: new Date() })