@zodic/shared 0.0.349 → 0.0.351

package/app/api/index.ts

@@ -1,5 +1,4 @@
 import OpenAI from 'openai';
-import { v4 } from 'uuid';
 import {
   BackendBindings,
   BatchInputItem,
@@ -12,7 +11,6 @@ import {
   NatalChartInterpretation,
 } from '../../types';
 import {
-  AstrologyApiResponse,
   ChatGPTOptions,
   HouseCuspsReport,
   LeonardoGenerateImageParams,
@@ -21,6 +19,12 @@ import {
   NatalHouseCuspReport,
   TimezoneResponse,
 } from '../../types/scopes/legacy';
+import {
+  resizeImage,
+  sendRequest,
+  uploadImageToStorage,
+  validateImageUrl,
+} from '../../utils/faceSwapHelpers';
 import { makeAstrologyApiCall } from './astrology';
 
 const deepseek = (env: BackendBindings) =>
@@ -781,87 +785,10 @@ export const Api = (env: BackendBindings) => ({
       taskId: string;
       message: string;
     }> => {
-      const endpoint = 'https://api.piapi.ai/api/v1/task';
-      const headers = {
-        'x-api-key': `${env.PIAPI_API_KEY}`,
-        'Content-Type': 'application/json',
-      };
-
-      // 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}`);
-        }
-      };
-
-      // Helper function to resize an image by calling the Express server
-      const resizeImage = async (
-        url: string,
-        label: string
-      ): Promise<ArrayBuffer> => {
-        const resizeEndpoint = `https://zodiako-image-mounter.onrender.com/resize-image?url=${encodeURIComponent(
-          url
-        )}`; // Replace with your Express server URL
-        try {
-          const response = await fetch(resizeEndpoint);
-          if (!response.ok) {
-            throw new Error(
-              `${label} resize failed: ${response.status} ${response.statusText}`
-            );
-          }
-          const contentType = response.headers.get('Content-Type');
-          if (!contentType || !contentType.startsWith('image/')) {
-            throw new Error(
-              `${label} resize response is not an image: Content-Type is ${contentType}`
-            );
-          }
-          return await response.arrayBuffer();
-        } catch (err: any) {
-          console.error(`Error resizing ${label}:`, err.message);
-          throw new Error(`Failed to resize ${label}: ${err.message}`);
-        }
-      };
-
-      const getKey = (label: string) => {
-        const timestamp = Date.now();
-        const key = `${label.toLowerCase().replace(/ /g, '_')}_${timestamp}.jpg`;
-        return key;
-      };
-
-      // Helper function to upload an image to storage and get a public URL
-      const uploadImageToStorage = async (
-        imageData: ArrayBuffer,
-        label: string
-      ): Promise<string> => {
-        const key = getKey(label);
-        await env.PHOTOS_BUCKET.put(key, imageData);
-        const imageUrl = `https://pub-bbc0cdb569734925ab1c39512bc4765d.r2.dev/${key}`;
-        return imageUrl;
-      };
-
       try {
-        // Validate image URLs
         await validateImageUrl(sourceImageUrl, 'Source image URL');
         await validateImageUrl(targetImageUrl, 'Target image URL');
 
-        // Resize images by calling the Express server
         const resizedSourceData = await resizeImage(
           sourceImageUrl,
           'Source image'
@@ -871,14 +798,15 @@ export const Api = (env: BackendBindings) => ({
           'Target image'
         );
 
-        // Upload resized images to storage to get public URLs
         const resizedSourceUrl = await uploadImageToStorage(
           resizedSourceData,
-          'user_photo'
+          'user_photo',
+          env
         );
         const resizedTargetUrl = await uploadImageToStorage(
           resizedTargetData,
-          'generated_image'
+          'generated_image',
+          env
         );
 
         const body = JSON.stringify({
@@ -902,73 +830,13 @@ export const Api = (env: BackendBindings) => ({
           resizedTargetUrl,
         });
 
-        const response = await fetch(endpoint, {
-          method: 'POST',
-          headers,
-          body,
-        });
-
-        // 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'
-            }`
-          );
-        }
-
-        // 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');
-        }
+        const responseData = await sendRequest(body, 1, env);
 
-        // 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);
+        console.log('FaceSwap task created successfully:', responseData);
 
         return {
-          taskId: data.task_id,
-          message: data.message,
+          taskId: responseData.data.task_id,
+          message: responseData.message,
         };
       } catch (err: any) {
         console.error('Error calling PiAPI FaceSwap:', err.message);
@@ -976,139 +844,4 @@ export const Api = (env: BackendBindings) => ({
       }
     },
   },
-
-  mock: {
-    callTimezone: async ({
-      lat,
-      lon,
-    }: {
-      lat: number;
-      lon: number;
-    }): Promise<TimezoneResponse> => {
-      console.log('Mocked callTimezone invoked', lat, lon);
-      await new Promise((resolve) => setTimeout(resolve, 3000)); // Simulate 3 seconds delay
-      return {
-        dstOffset: 3600, // Daylight saving time offset in seconds
-        rawOffset: -10800, // Standard time offset in seconds (UTC-3)
-        status: 'OK',
-        timeZoneId: 'America/Sao_Paulo', // Timezone ID for São Paulo
-        timeZoneName: 'Brasília Standard Time', // Official name for the timezone
-      };
-    },
-
-    callAstrology: async (params: {
-      day: number;
-      month: number;
-      year: number;
-      hour: number;
-      min: number;
-      lat: number;
-      lon: number;
-      tzone: number;
-    }): Promise<AstrologyApiResponse> => {
-      console.log('Mocked callAstrology invoked', params);
-      await new Promise((resolve) => setTimeout(resolve, 3000)); // Simulate 3 seconds delay
-      return [
-        {
-          name: 'Sun',
-          fullDegree: 259.3692854715937,
-          normDegree: 19.369285471593685,
-          speed: 1.0163786145803477,
-          isRetro: 'false',
-          sign: 'Sagittarius',
-          house: 11,
-        },
-        {
-          name: 'Moon',
-          fullDegree: 113.01532109301493,
-          normDegree: 23.015321093014933,
-          speed: 13.422889565180862,
-          isRetro: 'false',
-          sign: 'Libra',
-          house: 7,
-        },
-        {
-          name: 'Mars',
-          fullDegree: 319.2803341423472,
-          normDegree: 19.280334142347215,
-          speed: 0.7621766783897992,
-          isRetro: 'false',
-          sign: 'Aquarius',
-          house: 1,
-        },
-        {
-          name: 'Mercury',
-          fullDegree: 267.157142291648,
-          normDegree: 27.157142291647972,
-          speed: -1.129353838866472,
-          isRetro: 'true',
-          sign: 'Sagittarius',
-          house: 12,
-        },
-        {
-          name: 'Jupiter',
-          fullDegree: 286.74844079893995,
-          normDegree: 16.748440798939953,
-          speed: 0.21989257845513263,
-          isRetro: 'false',
-          sign: 'Capricorn',
-          house: 12,
-        },
-        {
-          name: 'Venus',
-          fullDegree: 302.46109957231073,
-          normDegree: 2.4610995723107294,
-          speed: 1.1733155507134867,
-          isRetro: 'false',
-          sign: 'Aquarius',
-          house: 1,
-        },
-        {
-          name: 'Saturn',
-          fullDegree: 232.5728863112664,
-          normDegree: 22.572886311266387,
-          speed: 0.1112696563244877,
-          isRetro: 'false',
-          sign: 'Scorpio',
-          house: 10,
-        },
-        {
-          name: 'Uranus',
-          fullDegree: 254.1300701628793,
-          normDegree: 14.130070162879292,
-          speed: 0.06114507772452163,
-          isRetro: 'false',
-          sign: 'Sagittarius',
-          house: 11,
-        },
-        {
-          name: 'Neptune',
-          fullDegree: 270.70233881243786,
-          normDegree: 0.7023388124378585,
-          speed: 0.037269287688777034,
-          isRetro: 'false',
-          sign: 'Capricorn',
-          house: 12,
-        },
-        {
-          name: 'Pluto',
-          fullDegree: 213.81656661729093,
-          normDegree: 3.816566617290931,
-          speed: 0.030884363476755057,
-          isRetro: 'false',
-          sign: 'Scorpio',
-          house: 9,
-        },
-        {
-          name: 'Ascendant',
-          fullDegree: 288.3761917494198,
-          normDegree: 18.376191749419775,
-          speed: 0,
-          isRetro: 'false',
-          sign: 'Aquarius',
-          house: 1,
-        },
-      ];
-    },
-  },
 });

package/package.json

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

package/types/scopes/generic.ts

@@ -598,4 +598,55 @@ export interface Composition {
   ascendant: ZodiacSignSlug;
   moon: ZodiacSignSlug;
   indexesToGenerate?: number[];
+}
+
+export interface ApidogModel {
+  code: number;
+  data: Data;
+  message: string;
+  [property: string]: any;
+}
+
+export interface Data {
+  detail: null;
+  error: Error | null;
+  input: { [key: string]: any };
+  logs: { [key: string]: any }[];
+  meta: Meta;
+  model: string;
+  output: { [key: string]: any };
+  status: Status;
+  task_id: string;
+  task_type: string;
+  [property: string]: any;
+}
+
+export interface Error {
+  code?: number;
+  message?: string;
+  [property: string]: any;
+}
+
+export interface Meta {
+  created_at?: string;
+  ended_at?: string;
+  is_using_private_pool: boolean;
+  started_at?: string;
+  usage: Usage;
+  [property: string]: any;
+}
+
+export interface Usage {
+  consume: number;
+  frozen: number;
+  type: string;
+  [property: string]: any;
+}
+
+export enum Status {
+  Completed = "Completed",
+  Failed = "Failed",
+  Pending = "Pending",
+  Processing = "Processing",
+  Staged = "Staged",
 }

package/utils/faceSwapHelpers.ts

@@ -0,0 +1,211 @@
+import { ApidogModel, BackendBindings, Status } from '../types';
+
+export 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}`);
+  }
+};
+
+// Helper function to resize an image by calling the Express server
+export const resizeImage = async (
+  url: string,
+  label: string
+): Promise<ArrayBuffer> => {
+  const resizeEndpoint = `https://zodiako-image-mounter.onrender.com/resize-image?url=${encodeURIComponent(
+    url
+  )}`;
+  try {
+    const response = await fetch(resizeEndpoint);
+    if (!response.ok) {
+      throw new Error(
+        `${label} resize failed: ${response.status} ${response.statusText}`
+      );
+    }
+    const contentType = response.headers.get('Content-Type');
+    if (!contentType || !contentType.startsWith('image/')) {
+      throw new Error(
+        `${label} resize response is not an image: Content-Type is ${contentType}`
+      );
+    }
+    return await response.arrayBuffer();
+  } catch (err: any) {
+    console.error(`Error resizing ${label}:`, err.message);
+    throw new Error(`Failed to resize ${label}: ${err.message}`);
+  }
+};
+
+export const getKey = (label: string) => {
+  const timestamp = Date.now();
+  const key = `${label.toLowerCase().replace(/ /g, '_')}_${timestamp}.jpg`;
+  return key;
+};
+
+// Helper function to upload an image to storage and get a public URL
+export const uploadImageToStorage = async (
+  imageData: ArrayBuffer,
+  label: string,
+  env: BackendBindings
+): Promise<string> => {
+  const key = getKey(label);
+  await env.PHOTOS_BUCKET.put(key, imageData);
+  const imageUrl = `https://pub-bbc0cdb569734925ab1c39512bc4765d.r2.dev/${key}`;
+  return imageUrl;
+};
+
+export const sendRequest = async (
+  body: string,
+  attempt: number = 1,
+  env: BackendBindings
+): Promise<ApidogModel> => {
+  const maxRetries = 3;
+  const retryDelay = 1000; // 1 second delay between retries
+  const endpoint = 'https://api.piapi.ai/api/v1/task';
+  const headers = {
+    'x-api-key': `${env.PIAPI_API_KEY}`,
+    'Content-Type': 'application/json',
+  };
+
+  try {
+    const response = await fetch(endpoint, {
+      method: 'POST',
+      headers,
+      body,
+    });
+
+    console.log('PiAPI FaceSwap Response Status:', response.status);
+    console.log('PiAPI FaceSwap Response Headers:', [
+      ...response.headers.entries(),
+    ]);
+
+    const responseText = await response.text();
+    console.log('PiAPI FaceSwap Raw Response Body:', responseText);
+
+    // Check for expected 201 Created or 200 OK status
+    if (response.status !== 201 && response.status !== 200) {
+      // Handle retryable status codes (429, 503)
+      if (
+        (response.status === 429 || response.status === 503) &&
+        attempt <= maxRetries
+      ) {
+        console.log(
+          `Attempt ${attempt} failed with status ${response.status}. Retrying in ${retryDelay}ms...`
+        );
+        await new Promise((resolve) => setTimeout(resolve, retryDelay));
+        return sendRequest(body, attempt + 1, env);
+      }
+
+      let errorData: any;
+      try {
+        errorData = JSON.parse(responseText);
+      } catch {
+        errorData = { message: responseText || 'Unknown error' };
+      }
+      throw new Error(
+        `PiAPI FaceSwap Error: ${response.status} - ${
+          errorData.message || 'Unknown error'
+        }`
+      );
+    }
+
+    // Log a warning if we get a 200 instead of the expected 201
+    if (response.status === 200) {
+      console.warn(
+        'PiAPI FaceSwap returned 200 OK instead of the expected 201 Created. This might indicate a documentation mismatch or unexpected API behavior.'
+      );
+    }
+
+    // Check if response body is empty
+    if (!responseText) {
+      throw new Error('PiAPI FaceSwap Error: Empty response body');
+    }
+
+    // Parse the response as JSON
+    let data: ApidogModel;
+    try {
+      data = JSON.parse(responseText) as ApidogModel;
+    } 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 ||
+      typeof data.code !== 'number' ||
+      !data.data ||
+      typeof data.message !== 'string'
+    ) {
+      console.error('PiAPI FaceSwap response missing required fields:', data);
+      throw new Error('PiAPI FaceSwap Error: Invalid response structure');
+    }
+
+    // Check the response code
+    if (data.code !== 0) {
+      const errorMsg = data.message || 'Unknown error';
+      const detailedError = data.data.error
+        ? ` - ${data.data.error.message || 'No detailed error message'}`
+        : '';
+      throw new Error(
+        `PiAPI FaceSwap Error: Code ${data.code} - ${errorMsg}${detailedError}`
+      );
+    }
+
+    // Validate the data structure
+    if (!data.data.task_id || !data.data.status) {
+      console.error('PiAPI FaceSwap data missing required fields:', data.data);
+      throw new Error('PiAPI FaceSwap Error: Invalid data structure');
+    }
+
+    // Check the task status
+    if (data.data.status === Status.Failed) {
+      const errorMsg =
+        data.data.error?.message || 'Task failed with unknown error';
+      throw new Error(`PiAPI FaceSwap Error: Task failed - ${errorMsg}`);
+    }
+
+    // Ensure the task is in a valid state for creation
+    if (
+      data.data.status !== Status.Staged &&
+      data.data.status !== Status.Pending &&
+      data.data.status !== Status.Processing
+    ) {
+      throw new Error(
+        `PiAPI FaceSwap Error: Unexpected task status - ${data.data.status}`
+      );
+    }
+
+    return data;
+  } catch (err: any) {
+    if (
+      attempt <= maxRetries &&
+      (err.message.includes('503') || err.message.includes('429'))
+    ) {
+      console.log(
+        `Attempt ${attempt} failed: ${err.message}. Retrying in ${retryDelay}ms...`
+      );
+      await new Promise((resolve) => setTimeout(resolve, retryDelay));
+      return sendRequest(body, attempt + 1, env);
+    }
+    throw err;
+  }
+};