@zodic/shared 0.0.338 → 0.0.340

package/app/api/index.ts

@@ -785,43 +785,96 @@ export const Api = (env: BackendBindings) => ({
         Authorization: `Bearer ${env.PIAPI_API_KEY}`,
         'Content-Type': 'application/json',
       };
-
-      const body = JSON.stringify({
-        model: 'Qubico/image-toolkit',
-        type: 'faceswap',
-        input: {
-          source_image_url: sourceImageUrl,
-          target_image_url: targetImageUrl,
-        },
-        config: {
-          webhook_config: {
-            endpoint:
-              'https://zodic-backend.lucdelbel.workers.dev/api/webhook/faceswap',
-            // secret: '',
-          },
-        },
-      });
-
+    
+      // Validate image URLs before making the request
+      const validateImageUrl = async (url: string, label: string): Promise<void> => {
+        try {
+          const response = await fetch(url, { method: 'HEAD' });
+          if (!response.ok) {
+            throw new Error(`${label} is inaccessible: ${response.status} ${response.statusText}`);
+          }
+          const contentType = response.headers.get('Content-Type');
+          if (!contentType || !contentType.startsWith('image/')) {
+            throw new Error(`${label} is not a valid image: Content-Type is ${contentType}`);
+          }
+        } catch (err: any) {
+          console.error(`Error validating ${label}:`, err.message);
+          throw new Error(`Invalid ${label}: ${err.message}`);
+        }
+      };
+    
       try {
+        // Validate image URLs
+        await validateImageUrl(sourceImageUrl, 'Source image URL');
+        await validateImageUrl(targetImageUrl, 'Target image URL');
+    
+        const body = JSON.stringify({
+          model: 'Qubico/image-toolkit',
+          type: 'faceswap',
+          input: {
+            source_image_url: sourceImageUrl,
+            target_image_url: targetImageUrl,
+          },
+          config: {
+            webhook_config: {
+              endpoint:
+                'https://zodic-backend.lucdelbel.workers.dev/api/webhook/faceswap',
+              // secret: '',
+            },
+          },
+        });
+    
+        console.log('Sending FaceSwap request:', { sourceImageUrl, targetImageUrl });
+    
         const response = await fetch(endpoint, {
           method: 'POST',
           headers,
           body,
         });
-
-        if (!response.ok) {
-          const error = await response.json();
-          console.error('Error from PiAPI FaceSwap:', error);
-          throw new Error(`PiAPI FaceSwap Error: ${response.status}`);
+    
+        // Log the HTTP status and headers for debugging
+        console.log('PiAPI FaceSwap Response Status:', response.status);
+        console.log('PiAPI FaceSwap Response Headers:', [...response.headers.entries()]);
+    
+        // Read the response body as text first to inspect it
+        const responseText = await response.text();
+        console.log('PiAPI FaceSwap Raw Response Body:', responseText);
+    
+        // Check for the expected 201 Created status
+        if (response.status !== 201) {
+          let errorData;
+          try {
+            errorData = JSON.parse(responseText);
+          } catch {
+            errorData = { message: responseText || 'Unknown error' };
+          }
+          console.error('Error from PiAPI FaceSwap:', errorData);
+          throw new Error(`PiAPI FaceSwap Error: ${response.status} - ${errorData.message || 'Unknown error'}`);
         }
-
-        const data = (await response.json()) as {
-          task_id: string;
-          message: string;
-        };
-
+    
+        // Check if the response body is empty
+        if (!responseText) {
+          console.error('PiAPI FaceSwap response body is empty');
+          throw new Error('PiAPI FaceSwap Error: Empty response body');
+        }
+    
+        // Try to parse the response as JSON
+        let data;
+        try {
+          data = JSON.parse(responseText) as { task_id: string; message: string };
+        } catch (err) {
+          console.error('Failed to parse PiAPI FaceSwap response as JSON:', responseText);
+          throw new Error('PiAPI FaceSwap Error: Invalid JSON response');
+        }
+    
+        // Validate the response structure
+        if (!data.task_id || !data.message) {
+          console.error('PiAPI FaceSwap response missing required fields:', data);
+          throw new Error('PiAPI FaceSwap Error: Invalid response structure');
+        }
+    
         console.log('FaceSwap task created successfully:', data);
-
+    
         return {
           taskId: data.task_id,
           message: data.message,

package/app/services/index.ts

@@ -1,4 +1,3 @@
-export * from './ConceptService';
 export * from './ArchetypeService';
+export * from './ConceptService';
 export * from './LeonardoService';
-export * from './ArtifactService';

package/package.json

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

package/app/services/ArtifactService.ts

@@ -1,104 +0,0 @@
-import { inject, injectable } from 'inversify';
-import { and, eq } from 'drizzle-orm';
-import { AppContext, schema } from '../..';
-import { BackendCtx } from '../../types/backend';
-import { ArtifactList } from '../../types';
-
-@injectable()
-export class ArtifactService {
-  constructor(@inject(AppContext) private context: AppContext) {}
-
-  private async log(
-    level: 'info' | 'debug' | 'warn' | 'error',
-    message: string,
-    context: Record<string, any> = {}
-  ) {
-    const logId = `artifact-service:${Date.now()}`;
-    const logMessage = `[${level.toUpperCase()}] ${message}`;
-
-    console[level](logMessage, context);
-    const db = this.context.drizzle();
-    try {
-      await db
-        .insert(schema.logs)
-        .values({
-          id: logId,
-          level,
-          message,
-          context: JSON.stringify(context),
-          createdAt: new Date().getTime(),
-        })
-        .execute();
-    } catch (error) {
-      console.error('[ERROR] Failed to persist log to database:', {
-        error,
-        logId,
-        message,
-        context,
-      });
-    }
-  }
-
-  async generateCosmicMirror(
-    artifactId: string,
-    userId: string,
-    generatedImageId: string,
-    archetypeDataId: string,
-    size: string
-  ) {
-    await this.log('info', 'Starting cosmic mirror generation', {
-      artifactId,
-      userId,
-      generatedImageId,
-      archetypeDataId,
-      size
-    });
-
-    const drizzle = this.context.drizzle();
-    const { artifacts, userArtifacts, generations, userConcepts } = schema;
-
-    // Implementation will be moved from ArtifactController
-  }
-
-  async cleanupStaleCosmicMirror(
-    userArtifact: typeof schema.userArtifacts.$inferSelect
-  ): Promise<void> {
-    await this.log('info', 'Cleaning up stale cosmic mirror', {
-      userArtifactId: userArtifact.id
-    });
-
-    const drizzle = this.context.drizzle();
-    const { generations } = schema;
-    
-    // Delete KV entries
-    const kvKeys = await this.context.kvCosmicMirrorManagementStore().list({
-      prefix: `cosmic-mirror:${userArtifact.id}:`
-    });
-    for (const key of kvKeys.keys) {
-      await this.context.kvCosmicMirrorManagementStore().delete(key.name);
-    }
-
-    // Delete generations
-    await drizzle
-      .delete(generations)
-      .where(eq(generations.userArtifactId, userArtifact.id));
-
-    // Delete user artifact
-    await drizzle
-      .delete(schema.userArtifacts)
-      .where(eq(schema.userArtifacts.id, userArtifact.id));
-  }
-
-  async retryStaleCosmicMirror(
-    userArtifact: typeof schema.userArtifacts.$inferSelect
-  ): Promise<any> {
-    await this.log('info', 'Retrying stale cosmic mirror', {
-      userArtifactId: userArtifact.id
-    });
-
-    const drizzle = this.context.drizzle();
-    const { users, artifactFaceswap } = schema;
-
-    // Implementation will be moved from ArtifactController
-  }
-}