@zodic/shared 0.0.37 → 0.0.38

package/api/index.ts

@@ -0,0 +1,702 @@
+import {
+  BackendBindings,
+  ChatMessages,
+  NatalChartInterpretation,
+} from '../types';
+import {
+  AstrologyApiResponse,
+  ChatGPTOptions,
+  HouseCuspsReport,
+  LeonardoGenerateImageParams,
+  LeonardoGenerateImageResponse,
+  LeonardoGeneratePresignedUrlParams,
+  LeonardoRequestBody,
+  LeonardoUploadImageParams,
+  NatalHouseCuspReport,
+  TimezoneResponse,
+} from '../types/scopes/legacy';
+import { makeAstrologyApiCall } from './astrology';
+
+export const Api = (env: BackendBindings) => ({
+  callChatGPT: async (
+    messages: ChatMessages,
+    { model = 'gpt-4', options = {} }: ChatGPTOptions
+  ): Promise<string> => {
+    const endpoint = 'https://api.openai.com/v1/chat/completions';
+    const headers = {
+      'Content-Type': 'application/json',
+      Authorization: `Bearer ${env.OPENAI_API_KEY}`,
+    };
+
+    const body = JSON.stringify({
+      model,
+      messages,
+      ...options,
+    });
+
+    try {
+      const response = await fetch(endpoint, { method: 'POST', headers, body });
+
+      if (!response.ok) {
+        const error = await response.json();
+        console.error('Error from OpenAI API:', error);
+        throw new Error(`OpenAI API Error: ${response.status}`);
+      }
+
+      const data = (await response.json()) as any;
+      return data.choices[0].message.content.trim() as string;
+    } catch (err: any) {
+      console.error('Error calling ChatGPT API:', err.message);
+      throw err;
+    }
+  },
+
+  callLeonardo: {
+    generateImage: async ({
+      prompt,
+      width,
+      height,
+      controlNets = [], // Optional
+      initImageId = null, // Optional
+      initStrength = 0.2, // Default strength for Image-to-Image
+      quantity = 3,
+    }: LeonardoGenerateImageParams & {
+      initImageId?: string | null;
+      initStrength?: number;
+    }): Promise<LeonardoGenerateImageResponse> => {
+      const fixedData = {
+        modelId: '2067ae52-33fd-4a82-bb92-c2c55e7d2786',
+        presetStyle: 'DYNAMIC',
+        alchemy: true,
+      };
+
+      const negativePrompt =
+        'blurry, boring, dark, low quality, lowres, grainy, distorted, overexposed, oversaturated, flat, rough, noisy, abstract, monochrome, dull, cracked, chipped, uneven, asymmetrical, deformed, pixelated, cartoonish, out of focus, messy, dull lighting, rough texture, unbalanced, low contrast, poorly drawn, faded colors, chaotic, unnatural metals, overly sharp colors, text, writing, letters, symbols, logos, watermark, calligraphy, caption, bad anatomy, malformed hands, extra fingers, missing fingers, poorly drawn face, distorted eyes, crossed eyes, out-of-proportion eyes, deformed limbs, floating limbs, disconnected limbs, mutated hands, elongated neck, unrealistic body proportions, disfigured, extra limbs, unnatural skin texture, melted features, unnatural fingers, poorly rendered hands, blurry face';
+
+      const endpoint = 'https://cloud.leonardo.ai/api/rest/v1/generations';
+      const headers = {
+        Authorization: `Bearer ${env.LEONARDO_API_KEY}`,
+        'Content-Type': 'application/json',
+      };
+
+      const body: LeonardoRequestBody = {
+        ...fixedData,
+        prompt,
+        width,
+        height,
+        negative_prompt: negativePrompt,
+        num_images: quantity,
+      };
+
+      if (controlNets.length > 0) {
+        body['controlnets'] = controlNets.map((net) => ({
+          initImageId: net.initImageId,
+          initImageType: net.initImageType,
+          preprocessorId: net.preprocessorId,
+          strengthType: net.strengthType,
+        }));
+      }
+
+      if (initImageId) {
+        body['init_generation_image_id'] = initImageId;
+        body['init_strength'] = initStrength;
+      }
+
+      try {
+        const response = await fetch(endpoint, {
+          method: 'POST',
+          headers,
+          body: JSON.stringify(body),
+        });
+
+        if (!response.ok) {
+          const error = await response.json();
+          console.error('Error from Leonardo API:', error);
+          throw new Error(`Leonardo API Error: ${response.status}`);
+        }
+
+        const data = (await response.json()) as LeonardoGenerateImageResponse;
+        return data;
+      } catch (err: any) {
+        console.error('Error calling Leonardo API:', err.message);
+        throw err;
+      }
+    },
+    generatePresignedUrl: async ({
+      extension,
+    }: LeonardoGeneratePresignedUrlParams): Promise<{
+      url: string;
+      fields: string;
+      id: string;
+      key: string;
+    }> => {
+      console.log('Generating presigned URL with extension:', extension);
+
+      const endpoint = 'https://cloud.leonardo.ai/api/rest/v1/init-image';
+      const headers = {
+        Authorization: `Bearer ${env.LEONARDO_API_KEY}`,
+        'Content-Type': 'application/json',
+      };
+
+      if (!extension) {
+        throw new Error('Invalid MIME type');
+      }
+
+      const body = JSON.stringify({
+        extension,
+      });
+
+      try {
+        const response = await fetch(endpoint, {
+          method: 'POST',
+          headers,
+          body,
+        });
+
+        if (!response.ok) {
+          const error = await response.text();
+          console.error('Leonardo API error:', error);
+          throw new Error(
+            `Presigned URL generation failed: ${response.status}`
+          );
+        }
+
+        const rawResponse = (await response.json()) as any;
+        console.log('Presigned URL response:', rawResponse);
+
+        if (
+          !rawResponse.uploadInitImage ||
+          !rawResponse.uploadInitImage.url ||
+          !rawResponse.uploadInitImage.fields
+        ) {
+          throw new Error('Invalid presigned URL response');
+        }
+
+        return rawResponse.uploadInitImage;
+      } catch (error: any) {
+        console.error('Error generating presigned URL:', error.message);
+        throw error;
+      }
+    },
+    uploadImage: async ({
+      presignedUrl,
+      fields,
+      file,
+    }: LeonardoUploadImageParams) => {
+      console.log('Starting image upload to:', presignedUrl);
+
+      if (!(file instanceof Blob)) {
+        throw new Error('Invalid file type for upload');
+      }
+
+      try {
+        console.log('Parsing fields...');
+        const parsedFields = JSON.parse(fields);
+
+        if (!parsedFields || typeof parsedFields !== 'object') {
+          throw new Error('Invalid fields format');
+        }
+
+        console.log('Parsed fields:', parsedFields);
+
+        const formData = new FormData();
+
+        Object.entries(parsedFields).forEach(([key, value]) => {
+          formData.append(key, value as string);
+        });
+
+        formData.append('file', file);
+
+        console.log('Uploading with FormData:', Array.from(formData.entries()));
+
+        const response = await fetch(presignedUrl, {
+          method: 'POST',
+          body: formData,
+        });
+
+        if (!response.ok) {
+          const errorDetails = await response.text();
+          console.error('Upload failed:', errorDetails);
+          throw new Error(`Image upload failed: ${response.status}`);
+        }
+
+        console.log('Image uploaded successfully');
+      } catch (error: any) {
+        console.error('Error during uploadImage:', error.message);
+        throw error;
+      }
+    },
+  },
+
+  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 ({
+      day,
+      month,
+      year,
+      hour,
+      min,
+      lat,
+      lon,
+      tzone,
+    }: {
+      day: number;
+      month: number;
+      year: number;
+      hour: number;
+      min: number;
+      lat: number;
+      lon: number;
+      tzone: number;
+    }): Promise<NatalChartInterpretation> => {
+      const path = `natal_chart_interpretation`;
+      const payload = { day, month, year, hour, min, lat, lon, tzone };
+
+      return makeAstrologyApiCall(path, payload, env);
+    },
+
+    getHouseCuspsReport: async ({
+      day,
+      month,
+      year,
+      hour,
+      min,
+      lat,
+      lon,
+      tzone,
+    }: {
+      day: number;
+      month: number;
+      year: number;
+      hour: number;
+      min: number;
+      lat: number;
+      lon: number;
+      tzone: number;
+    }): Promise<HouseCuspsReport[]> => {
+      const path = `house_cusps_report/tropical`;
+      const payload = { day, month, year, hour, min, lat, lon, tzone };
+
+      return makeAstrologyApiCall(path, payload, env);
+    },
+
+    getNatalHouseCuspReports: async ({
+      day,
+      month,
+      year,
+      hour,
+      min,
+      lat,
+      lon,
+      tzone,
+    }: {
+      day: number;
+      month: number;
+      year: number;
+      hour: number;
+      min: number;
+      lat: number;
+      lon: number;
+      tzone: number;
+    }): Promise<NatalHouseCuspReport[]> => {
+      const path = `natal_house_cusp_report`;
+      const payload = { day, month, year, hour, min, lat, lon, tzone };
+
+      return makeAstrologyApiCall(path, payload, env);
+    },
+
+    getPlanetSignReport: async ({
+      planetName,
+      day,
+      month,
+      year,
+      hour,
+      min,
+      lat,
+      lon,
+      tzone,
+    }: {
+      planetName: string;
+      day: number;
+      month: number;
+      year: number;
+      hour: number;
+      min: number;
+      lat: number;
+      lon: number;
+      tzone: number;
+    }): Promise<{ planet_name: string; sign: string; report: string }> => {
+      const path = `general_sign_report/tropical/${planetName}`;
+      const payload = { day, month, year, hour, min, lat, lon, tzone };
+
+      return makeAstrologyApiCall(path, payload, env);
+    },
+
+    getAscendantReport: async ({
+      day,
+      month,
+      year,
+      hour,
+      min,
+      lat,
+      lon,
+      tzone,
+    }: {
+      day: number;
+      month: number;
+      year: number;
+      hour: number;
+      min: number;
+      lat: number;
+      lon: number;
+      tzone: number;
+    }): Promise<{ ascendant: string; report: string }> => {
+      const path = `general_ascendant_report/tropical`;
+      const payload = { day, month, year, hour, min, lat, lon, tzone };
+
+      return makeAstrologyApiCall(path, payload, env);
+    },
+  },
+
+  callTimezone: async ({
+    lat,
+    lon,
+  }: {
+    lat: number;
+    lon: number;
+  }): Promise<number> => {
+    const timestamp = Math.floor(Date.now() / 1000);
+    const url = `https://maps.googleapis.com/maps/api/timezone/json?location=${lat},${lon}&timestamp=${timestamp}&key=${env.GOOGLE_TIMEZONE_API_KEY}`;
+
+    try {
+      const response = await fetch(url);
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(
+          `Timezone API call failed: ${response.statusText} - ${errorText}`
+        );
+      }
+
+      const data = (await response.json()) as TimezoneResponse;
+
+      if (data.status !== 'OK') {
+        throw new Error(`Timezone API error: ${data.status}`);
+      }
+
+      const tzone = (data.rawOffset + data.dstOffset) / 3600;
+
+      return tzone;
+    } catch (error) {
+      console.error('Error calling Timezone API:', error);
+      throw new Error('Failed to fetch timezone data');
+    }
+  },
+
+  callPiApi: {
+    faceSwap: async ({
+      sourceImageUrl,
+      targetImageUrl,
+    }: {
+      sourceImageUrl: string;
+      targetImageUrl: string;
+    }): Promise<{
+      taskId: string;
+      message: string;
+    }> => {
+      const endpoint = 'https://api.piapi.ai/api/v1/task';
+      const headers = {
+        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: '',
+          },
+        },
+      });
+
+      try {
+        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}`);
+        }
+
+        const data = (await response.json()) as {
+          task_id: string;
+          message: string;
+        };
+
+        console.log('FaceSwap task created successfully:', data);
+
+        return {
+          taskId: data.task_id,
+          message: data.message,
+        };
+      } catch (err: any) {
+        console.error('Error calling PiAPI FaceSwap:', err.message);
+        throw err;
+      }
+    },
+  },
+
+  mock: {
+    callTimezone: async ({
+      lat,
+      lon,
+    }: {
+      lat: number;
+      lon: number;
+    }): Promise<TimezoneResponse> => {
+      console.log('Mocked callTimezone invoked');
+      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 ({
+      day,
+      month,
+      year,
+      hour,
+      min,
+      lat,
+      lon,
+      tzone,
+    }: {
+      day: number;
+      month: number;
+      year: number;
+      hour: number;
+      min: number;
+      lat: number;
+      lon: number;
+      tzone: number;
+    }): Promise<AstrologyApiResponse> => {
+      console.log('Mocked callAstrology invoked');
+      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,
+        },
+      ];
+    },
+  },
+});