@zodic/shared 0.0.236 → 0.0.238

package/app/services/ConceptService.ts

@@ -550,22 +550,20 @@ export class ConceptService {
     structuredContentEN: StructuredConceptContent;
     structuredContentPT: StructuredConceptContent;
   }> {
-    console.log(
-      `📌 [START] Parsing structured content for ${conceptSlug} from ChatGPT response.`
-    );
+    console.log(`📌 [START] Parsing structured content for ${conceptSlug}`);
 
     // ✅ Step 1: Clean artifacts before processing
     let cleanedResponse = response
       .replace(/[*#•]/g, '') // Remove bullet points, bold markers, headings
       .replace(/---+/g, '') // Remove dividers (like "---")
       .replace(/\n\s*\n/g, '\n\n') // Normalize multiple line breaks
-      .replace(/\s+EN:\s*/g, '\nEN: ') // Ensure consistent "EN:" formatting
-      .replace(/\s+PT:\s*/g, '\nPT: ') // Ensure consistent "PT:" formatting
+      .replace(/\s+EN:\s*/g, '\nEN: ') // Normalize "EN:"
+      .replace(/\s+PT:\s*/g, '\nPT: ') // Normalize "PT:"
       .trim();
 
     console.log(
       '🔹 [CLEANED RESPONSE]:',
-      cleanedResponse.slice(0, 500) + '...'
+      cleanedResponse.slice(0, 3000) + '...'
     );
 
     try {
@@ -677,12 +675,13 @@ export class ConceptService {
       }
 
       // ✅ Step 3: Detect if AI interleaved EN/PT sections
-      const interleavedMatches = cleanedResponse.match(
-        /(EN:\s*[\s\S]+?PT:\s*[\s\S]+?)(?=EN:|$)/
-      );
       let extractedEN = '';
       let extractedPT = '';
 
+      const interleavedMatches = cleanedResponse.match(
+        /(EN:\s*[\s\S]+?PT:\s*[\s\S]+?)(?=EN:|$)/g
+      );
+
       if (interleavedMatches) {
         console.warn(
           '⚠️ Detected interleaved EN/PT sections. Parsing accordingly.'
@@ -706,21 +705,21 @@ export class ConceptService {
       }
 
       console.log(
-        '✅ [MATCH SUCCESS] Extracted English Content:',
-        extractedEN.slice(0, 500) + '...'
+        '✅ Extracted English Content:',
+        extractedEN.slice(0, 1000) + '...'
       );
       console.log(
-        '✅ [MATCH SUCCESS] Extracted Portuguese Content:',
-        extractedPT.slice(0, 500) + '...'
+        '✅ Extracted Portuguese Content:',
+        extractedPT.slice(0, 1000) + '...'
       );
 
       // ✅ Step 4: Extract structured sections dynamically
       function extractSections(text: string, sectionTitles: string[]) {
         return sectionTitles.map((title) => {
-          console.log(`🔍 [PROCESSING] Extracting section: "${title}"`);
+          console.log(`🔍 Extracting section: "${title}"`);
 
           const regex = new RegExp(
-            `\\d+\\.\\s*${title}:\\s*([\\s\\S]+?)(?=\\n\\d+\\.\\s*[A-Z]|$)`
+            `(?:\\d+\\.\\s*)?${title}\\s*:?\\s*([\\s\\S]+?)(?=\\n(?:\\d+\\.\\s*)?[A-Z]|$)`
           );
           const match = text.match(regex);
 
@@ -734,10 +733,7 @@ export class ConceptService {
             .map((p) => p.trim())
             .filter((p) => p.length > 0);
 
-          console.log(
-            `✅ [EXTRACTED] "${title}" - Parsed Content:`,
-            paragraphs
-          );
+          console.log(`✅ Extracted "${title}" - Parsed Content:`, paragraphs);
           return { type: 'section', title, content: paragraphs };
         });
       }
@@ -746,17 +742,15 @@ export class ConceptService {
       const structuredContentPT = extractSections(extractedPT, sectionsPT);
 
       console.log(
-        '🎯 [FINAL RESULT] Parsed English Content:',
+        '🎯 Parsed English Content:',
         JSON.stringify(structuredContentEN, null, 2)
       );
       console.log(
-        '🎯 [FINAL RESULT] Parsed Portuguese Content:',
+        '🎯 Parsed Portuguese Content:',
         JSON.stringify(structuredContentPT, null, 2)
       );
 
-      console.log(
-        '✅ [COMPLETE] Structured content parsing finished successfully.'
-      );
+      console.log('✅ Structured content parsing finished successfully.');
 
       return {
         structuredContentEN,
@@ -784,6 +778,247 @@ export class ConceptService {
     }
   }
 
+  // async parseStructuredContent(
+  //   conceptSlug: Concept,
+  //   response: string
+  // ): Promise<{
+  //   structuredContentEN: StructuredConceptContent;
+  //   structuredContentPT: StructuredConceptContent;
+  // }> {
+  //   console.log(
+  //     `📌 [START] Parsing structured content for ${conceptSlug} from ChatGPT response.`
+  //   );
+
+  //   // ✅ Step 1: Clean artifacts before processing
+  //   let cleanedResponse = response
+  //     .replace(/[*#•]/g, '') // Remove bullet points, bold markers, headings
+  //     .replace(/---+/g, '') // Remove dividers (like "---")
+  //     .replace(/\n\s*\n/g, '\n\n') // Normalize multiple line breaks
+  //     .replace(/\s+EN:\s*/g, '\nEN: ') // Ensure consistent "EN:" formatting
+  //     .replace(/\s+PT:\s*/g, '\nPT: ') // Ensure consistent "PT:" formatting
+  //     .trim();
+
+  //   console.log(
+  //     '🔹 [CLEANED RESPONSE]:',
+  //     cleanedResponse.slice(0, 500) + '...'
+  //   );
+
+  //   try {
+  //     // ✅ Step 2: Define Section Titles Per Concept
+  //     const conceptSections: Record<string, { en: string[]; pt: string[] }> = {
+  //       crown: {
+  //         en: [
+  //           'Core Identity',
+  //           'Strengths and Challenges',
+  //           'Path to Fulfillment',
+  //           'Emotional Depth',
+  //           'Vision and Aspirations',
+  //         ],
+  //         pt: [
+  //           'Identidade Essencial',
+  //           'Forças e Desafios',
+  //           'Caminho para a Plenitude',
+  //           'Profundidade Emocional',
+  //           'Visão e Aspirações',
+  //         ],
+  //       },
+  //       scepter: {
+  //         en: [
+  //           'The Power of Expression',
+  //           'The Dance of Action and Reaction',
+  //           'Navigating Challenges',
+  //           'The Mirror of Relations',
+  //           'Impact on the World',
+  //         ],
+  //         pt: [
+  //           'O Poder da Expressão',
+  //           'A Dança da Ação e Reação',
+  //           'Navegando Desafios',
+  //           'O Espelho das Relações',
+  //           'Impacto no Mundo',
+  //         ],
+  //       },
+  //       amulet: {
+  //         en: [
+  //           'The Shield of Protection',
+  //           'The Strength Within',
+  //           'Nurturing Growth',
+  //           'The Cycle of Renewal',
+  //           'The Anchor of Wisdom',
+  //         ],
+  //         pt: [
+  //           'O Escudo da Proteção',
+  //           'A Força Interior',
+  //           'Cultivando o Crescimento',
+  //           'O Ciclo da Renovação',
+  //           'A Âncora da Sabedoria',
+  //         ],
+  //       },
+  //       ring: {
+  //         en: [
+  //           'Magnetic Pull',
+  //           'Hidden Desires',
+  //           'The Fated Dance',
+  //           'Unveiling the Shadows',
+  //           'Your Love Power',
+  //         ],
+  //         pt: [
+  //           'Força Magnética',
+  //           'Desejos Ocultos',
+  //           'A Dança do Destino',
+  //           'Revelando as Sombras',
+  //           'Seu Poder no Amor',
+  //         ],
+  //       },
+  //       lantern: {
+  //         en: [
+  //           'The Call to Awakening',
+  //           'Walking Through Shadows',
+  //           'The Inner Flame',
+  //           'Revelations and Truths',
+  //           'Becoming the Light',
+  //         ],
+  //         pt: [
+  //           'O Chamado para o Despertar',
+  //           'Caminhando Pelas Sombras',
+  //           'A Chama Interior',
+  //           'Revelações e Verdades',
+  //           'Tornando-se a Luz',
+  //         ],
+  //       },
+  //       orb: {
+  //         en: [
+  //           'The Path Unfolding',
+  //           'A Calling Beyond the Self',
+  //           'Turning Points of Fate',
+  //           'Mastering the Journey',
+  //           'Legacy and Impact',
+  //         ],
+  //         pt: [
+  //           'O Caminho que se Revela',
+  //           'Um Chamado Além de Si Mesmo',
+  //           'Pontos de Virada do Destino',
+  //           'Dominando a Jornada',
+  //           'Legado e Impacto',
+  //         ],
+  //       },
+  //     };
+
+  //     const sectionsEN = conceptSections[conceptSlug]?.en;
+  //     const sectionsPT = conceptSections[conceptSlug]?.pt;
+
+  //     if (!sectionsEN || !sectionsPT) {
+  //       throw new Error(`Unknown concept: ${conceptSlug}`);
+  //     }
+
+  //     // ✅ Step 3: Detect if AI interleaved EN/PT sections
+  //     const interleavedMatches = cleanedResponse.match(
+  //       /(EN:\s*[\s\S]+?PT:\s*[\s\S]+?)(?=EN:|$)/
+  //     );
+  //     let extractedEN = '';
+  //     let extractedPT = '';
+
+  //     if (interleavedMatches) {
+  //       console.warn(
+  //         '⚠️ Detected interleaved EN/PT sections. Parsing accordingly.'
+  //       );
+  //       extractedEN = interleavedMatches
+  //         .map(
+  //           (pair) => pair.match(/EN:\s*([\s\S]+?)\s*PT:/)?.[1]?.trim() || ''
+  //         )
+  //         .join('\n\n');
+  //       extractedPT = interleavedMatches
+  //         .map((pair) => pair.match(/PT:\s*([\s\S]+)/)?.[1]?.trim() || '')
+  //         .join('\n\n');
+  //     } else {
+  //       console.log(
+  //         '✅ Standard format detected (EN block followed by PT block).'
+  //       );
+  //       extractedEN =
+  //         cleanedResponse.match(/EN:\s*([\s\S]+?)\s*PT:/)?.[1]?.trim() || '';
+  //       extractedPT =
+  //         cleanedResponse.match(/PT:\s*([\s\S]+)/)?.[1]?.trim() || '';
+  //     }
+
+  //     console.log(
+  //       '✅ [MATCH SUCCESS] Extracted English Content:',
+  //       extractedEN.slice(0, 500) + '...'
+  //     );
+  //     console.log(
+  //       '✅ [MATCH SUCCESS] Extracted Portuguese Content:',
+  //       extractedPT.slice(0, 500) + '...'
+  //     );
+
+  //     // ✅ Step 4: Extract structured sections dynamically
+  //     function extractSections(text: string, sectionTitles: string[]) {
+  //       return sectionTitles.map((title) => {
+  //         console.log(`🔍 [PROCESSING] Extracting section: "${title}"`);
+
+  //         const regex = new RegExp(
+  //           `\\d+\\.\\s*${title}:\\s*([\\s\\S]+?)(?=\\n\\d+\\.\\s*[A-Z]|$)`
+  //         );
+  //         const match = text.match(regex);
+
+  //         if (!match) {
+  //           throw new Error(`❌ Missing section: "${title}"`);
+  //         }
+
+  //         const paragraphs = match[1]
+  //           .trim()
+  //           .split(/\n{2,}/)
+  //           .map((p) => p.trim())
+  //           .filter((p) => p.length > 0);
+
+  //         console.log(
+  //           `✅ [EXTRACTED] "${title}" - Parsed Content:`,
+  //           paragraphs
+  //         );
+  //         return { type: 'section', title, content: paragraphs };
+  //       });
+  //     }
+
+  //     const structuredContentEN = extractSections(extractedEN, sectionsEN);
+  //     const structuredContentPT = extractSections(extractedPT, sectionsPT);
+
+  //     console.log(
+  //       '🎯 [FINAL RESULT] Parsed English Content:',
+  //       JSON.stringify(structuredContentEN, null, 2)
+  //     );
+  //     console.log(
+  //       '🎯 [FINAL RESULT] Parsed Portuguese Content:',
+  //       JSON.stringify(structuredContentPT, null, 2)
+  //     );
+
+  //     console.log(
+  //       '✅ [COMPLETE] Structured content parsing finished successfully.'
+  //     );
+
+  //     return {
+  //       structuredContentEN,
+  //       structuredContentPT,
+  //     };
+  //   } catch (error) {
+  //     console.error(`❌ Parsing failed for ${conceptSlug}. Logging failure.`);
+
+  //     // ✅ Store failure in KV for debugging
+  //     const kvFailuresStore = this.context.kvConceptFailuresStore();
+  //     const failureKey = `failures:content:parsing:${conceptSlug}:${new Date().toISOString()}`;
+
+  //     await kvFailuresStore.put(
+  //       failureKey,
+  //       JSON.stringify({
+  //         error: (error as Error).message,
+  //         conceptSlug,
+  //         cleanedResponse,
+  //         timestamp: new Date().toISOString(),
+  //       })
+  //     );
+
+  //     console.error(`🚨 Failure logged in KV: ${failureKey}`);
+  //     throw error;
+  //   }
+  // }
+
   // private parseStructuredContent(
   //   conceptSlug: Concept,
   //   response: string

package/db/schema.ts

@@ -181,6 +181,68 @@ export const astroAspects = sqliteTable(
   ]
 );
 
+export const astroReports = sqliteTable(
+  "astro_reports",
+  {
+    id: text("id").primaryKey(), // Unique identifier
+    type: text("type").notNull(), // 'planet', 'key_point', 'karmic_point', 'hermetic_part'
+    name: text("name").notNull(), // Slug (e.g., 'sun', 'pars_fortuna')
+    sign: text("sign"), // Slug (e.g., 'aries', 'taurus') - nullable for house-only reports
+    house: integer("house"), // Nullable, only for applicable placements
+    enDescription: text("en_description"), // General explanation of the placement
+    ptDescription: text("pt_description"),
+    enReport: text("en_report"), // Full report content in English
+    ptReport: text("pt_report"), // Full report content in Portuguese
+    createdAt: integer("created_at").default(sql`CURRENT_TIMESTAMP`),
+    updatedAt: integer("updated_at").default(sql`CURRENT_TIMESTAMP`),
+  },
+  (t) => [
+    index("astro_reports_type_idx").on(t.type),
+    index("astro_reports_name_sign_idx").on(t.name, t.sign), // Most critical index (name + sign)
+    index("astro_reports_name_house_idx").on(t.name, t.house), // Most critical index (name + house)
+  ]
+);
+
+export const houseReports = sqliteTable(
+  "house_reports",
+  {
+    id: text("id").primaryKey(), // Unique identifier
+    sign: text("sign").notNull(), // Lowercase slug (e.g., 'aries', 'taurus')
+    house: integer("house").notNull(), // House placement (1-12)
+    enDescription: text("en_description"), // General explanation of the sign in a house
+    ptDescription: text("pt_description"),
+    enReport: text("en_report"), // Full report content in English
+    ptReport: text("pt_report"), // Full report content in Portuguese
+    createdAt: integer("created_at").default(sql`CURRENT_TIMESTAMP`),
+    updatedAt: integer("updated_at").default(sql`CURRENT_TIMESTAMP`),
+  },
+  (t) => [
+    index("house_reports_sign_house_idx").on(t.sign, t.house), // Optimized index for sign + house lookups
+  ]
+);
+
+export const aspectReports = sqliteTable(
+  "aspect_reports",
+  {
+    id: text("id").primaryKey(), // Unique identifier
+    aspectingPlanet: text("aspecting_planet").notNull(), // Planet/point initiating the aspect (e.g., 'sun', 'mars')
+    aspectedPlanet: text("aspected_planet").notNull(), // Planet/point receiving the aspect (e.g., 'moon', 'venus')
+    aspect: text("aspect").notNull(), // Aspect type ('conjunction', 'trine', 'square', etc.)
+    enDescription: text("en_description"), // General explanation of the aspect
+    ptDescription: text("pt_description"),
+    enReport: text("en_report"), // Full report content in English
+    ptReport: text("pt_report"), // Full report content in Portuguese
+    createdAt: integer("created_at").default(sql`CURRENT_TIMESTAMP`),
+    updatedAt: integer("updated_at").default(sql`CURRENT_TIMESTAMP`),
+  },
+  (t) => [
+    index("aspect_reports_aspecting_idx").on(t.aspectingPlanet),
+    index("aspect_reports_aspected_idx").on(t.aspectedPlanet),
+    index("aspect_reports_aspect_idx").on(t.aspect),
+    index("aspect_reports_combined_idx").on(t.aspectingPlanet, t.aspectedPlanet, t.aspect), // Optimized for aspect lookups
+  ]
+);
+
 export const concepts = sqliteTable(
   'concepts',
   {

package/package.json

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

package/types/scopes/legacy.ts

@@ -1,21 +1,109 @@
+import { pointNameMap } from '../../utils/astroPrompts/pointNameMap';
 import { BackendBindings } from './cloudflare';
 import { ControlNetConfig, Gender } from './generic';
 
 export const zodiacSigns = [
-  'Aries',
-  'Taurus',
-  'Gemini',
-  'Cancer',
-  'Leo',
-  'Virgo',
-  'Libra',
-  'Scorpio',
-  'Sagittarius',
-  'Capricorn',
-  'Aquarius',
-  'Pisces',
+  "aries",
+  "taurus",
+  "gemini",
+  "cancer",
+  "leo",
+  "virgo",
+  "libra",
+  "scorpio",
+  "sagittarius",
+  "capricorn",
+  "aquarius",
+  "pisces",
+] as const;
+export type ZodiacSignSlug = (typeof zodiacSigns)[number];
+
+// Houses
+export const houses = Array.from({ length: 12 }, (_, i) => i + 1);
+
+// Aspects
+const aspects = ["conjunction", "opposition", "trine", "square", "sextile"] as const;
+export type AspectType = (typeof aspects)[number];
+
+export const pointTypes: Record<PointSlug, string> = {
+  sun: "planet",
+  moon: "planet",
+  mercury: "planet",
+  venus: "planet",
+  mars: "planet",
+  jupiter: "planet",
+  saturn: "planet",
+  uranus: "planet",
+  neptune: "planet",
+  pluto: "planet",
+  ascendant: "key_point",
+  descendant: "key_point",
+  midheaven: "key_point",
+  imum_coeli: "key_point",
+  north_node: "karmic_point",
+  south_node: "karmic_point",
+  chiron: "karmic_point",
+  lilith: "hermetic_part",
+  vertex: "hermetic_part",
+  antivertex: "hermetic_part",
+  pars_fortuna: "hermetic_part",
+  pars_spiritus: "hermetic_part",
+  pars_victoria: "hermetic_part",
+  pars_amoris: "hermetic_part",
+  pars_eros: "hermetic_part",
+  pars_fortitudo: "hermetic_part",
+  pars_necessitatis: "hermetic_part",
+};
+
+// Subset of 14 points for aspects
+export const aspectPoints: PointSlug[] = [
+  "sun",
+  "moon",
+  "mercury",
+  "venus",
+  "mars",
+  "jupiter",
+  "saturn",
+  "uranus",
+  "neptune",
+  "pluto",
+  "ascendant",
+  "descendant",
+  "midheaven",
+  "imum_coeli",
 ];
 
+export type PointSlug = keyof typeof pointNameMap;
+
+export type ZodiacSign =
+  | 'aries'
+  | 'taurus'
+  | 'gemini'
+  | 'cancer'
+  | 'leo'
+  | 'virgo'
+  | 'libra'
+  | 'scorpio'
+  | 'sagittarius'
+  | 'capricorn'
+  | 'aquarius'
+  | 'pisces';
+
+export const zodiacSignMap: Record<ZodiacSign, string> = {
+  aries: 'Aries',
+  taurus: 'Taurus',
+  gemini: 'Gemini',
+  cancer: 'Cancer',
+  leo: 'Leo',
+  virgo: 'Virgo',
+  libra: 'Libra',
+  scorpio: 'Scorpio',
+  sagittarius: 'Sagittarius',
+  capricorn: 'Capricorn',
+  aquarius: 'Aquarius',
+  pisces: 'Pisces',
+};
+
 export interface ChatGPTOptions {
   model?: string;
   options?: Record<string, any>;

package/utils/astroPrompts/index.ts

@@ -0,0 +1,91 @@
+import { PointSlug, ZodiacSign, zodiacSignMap } from '../../types/scopes/legacy';
+import { pointNameMap } from './pointNameMap';
+
+// Interfaces for each function's parameters
+interface PlanetOrPointParams {
+  type: 'planet' | 'key_point' | 'karmic_point' | 'hermetic_part';
+  sign: ZodiacSign;
+  pointName: PointSlug;
+}
+
+interface HouseParams {
+  houseNumber: number; // e.g., "1", "2", etc.
+  sign: ZodiacSign;
+}
+
+interface AspectParams {
+  aspectingPlanet: PointSlug;
+  aspectedPlanet: PointSlug;
+  aspectingType: string; // e.g., "conjunct", "square", "trine"
+}
+
+// Modular astroPrompts object
+export const astroPrompts = {
+  planetOrPoint: ({ type, sign, pointName }: PlanetOrPointParams): string => {
+    const validTypes = ['planet', 'key_point', 'karmic_point', 'hermetic_part'];
+    if (!validTypes.includes(type)) {
+      throw new Error(
+        `Invalid type for planetOrPoint: ${type}. Must be one of ${validTypes.join(
+          ', '
+        )}`
+      );
+    }
+
+    const formattedPointName = pointNameMap[pointName] || pointName;
+    return `
+      Make me a report for the astrological placement: ${formattedPointName} in ${zodiacSignMap[sign]}.
+      The response should include an English version and a Portuguese version.
+      Use "###" for titles and "####" for subtitles.
+      The response format should be exactly like this:
+
+      -- EN
+
+      [English Report - structured with headings, sections, and detailed explanations]
+
+      -- PT
+
+      [Portuguese Report - structured exactly the same as the English version]
+    `.trim();
+  },
+
+  house: ({ houseNumber, sign }: HouseParams): string => {
+    return `
+      Make me a report for the astrological placement: House ${houseNumber} in ${zodiacSignMap[sign]}.
+      The response should include an English version and a Portuguese version.
+      Use "###" for titles and "####" for subtitles.
+      The response format should be exactly like this:
+
+      -- EN
+
+      [English Report - structured with headings, sections, and detailed explanations]
+
+      -- PT
+
+      [Portuguese Report - structured exactly the same as the English version]
+    `.trim();
+  },
+
+  aspect: ({
+    aspectingPlanet,
+    aspectedPlanet,
+    aspectingType,
+  }: AspectParams): string => {
+    return `
+      Make me a report for the astrological aspect: ${
+        pointNameMap[aspectingPlanet] || aspectingPlanet
+      } ${aspectingType} ${pointNameMap[aspectedPlanet] || aspectedPlanet}.
+      The response should include an English version and a Portuguese version.
+      Use "###" for titles and "####" for subtitles.
+      The response format should be exactly like this:
+
+      -- EN
+
+      [English Report - structured with headings, sections, and detailed explanations]
+
+      -- PT
+
+      [Portuguese Report - structured exactly the same as the English version]
+    `.trim();
+  },
+};
+

package/utils/astroPrompts/pointNameMap.ts

@@ -0,0 +1,29 @@
+export const pointNameMap: Record<string, string> = {
+  sun: "Sun",
+  moon: "Moon",
+  mercury: "Mercury",
+  venus: "Venus",
+  mars: "Mars",
+  jupiter: "Jupiter",
+  saturn: "Saturn",
+  uranus: "Uranus",
+  neptune: "Neptune",
+  pluto: "Pluto",
+  ascendant: "Ascendant",
+  descendant: "Descendant",
+  midheaven: "Midheaven",
+  imum_coeli: "Imum Coeli",
+  north_node: "North Node",
+  south_node: "South Node",
+  chiron: "Chiron",
+  lilith: "Lilith",
+  vertex: "Vertex",
+  antivertex: "Antivertex",
+  pars_fortuna: "Pars Fortuna",
+  pars_spiritus: "Pars Spiritus",
+  pars_victoria: "Pars Victoria",
+  pars_amoris: "Pars Amoris",
+  pars_eros: "Pars Eros",
+  pars_fortitudo: "Pars Fortitudo",
+  pars_necessitatis: "Pars Necessitatis",
+};

package/utils/index.ts

@@ -101,7 +101,9 @@ export const verifyToken = async (
   }
 };
 
-export const providers: (c: AuthCtx) => Record<Provider, ProviderInfo> = (c) => ({
+export const providers: (c: AuthCtx) => Record<Provider, ProviderInfo> = (
+  c
+) => ({
   google: {
     serverUrl: 'https://accounts.google.com/.well-known/openid-configuration', // ✅ Correct Discovery URL
     clientId: c.env.GOOGLE_OAUTH_CLIENT_ID!,
@@ -120,3 +122,10 @@ export function normalizeName(name: string): string {
   return name.toLowerCase().replace(/\s+/g, '-');
 }
 
+export function chunkArray<T>(array: T[], size: number): T[][] {
+  const result = [];
+  for (let i = 0; i < array.length; i += size) {
+    result.push(array.slice(i, i + size));
+  }
+  return result;
+}