Fetch steading/fronts from map

Author: sheibeck

src/services/campaignService.ts

@@ -25,7 +25,7 @@ const parseCampaign = (raw: any): Campaign | null => {
   };
 };
 
-export const getCampaigns = async (userId: string): Promise<Campaign[]> => {
+export const getCampaigns = async (userId: string): Promise<Campaign[] | string> => {
   try {
     const { data } = await client.graphql({
       query: queries.listCampaigns,
@@ -39,59 +39,66 @@ export const getCampaigns = async (userId: string): Promise<Campaign[]> => {
     return rawItems.map(parseCampaign).filter(Boolean) as Campaign[];
   } catch (error) {
     console.error('Error fetching campaigns:', error);
-    return [];
+    return 'Error fetching campaigns';
   }
 };
 
-export const getCampaign = async (id: string): Promise<Campaign | null> => {
+export const getCampaign = async (id: string): Promise<Campaign | string> => {
   try {
     const { data } = await client.graphql({
       query: queries.getCampaign,
       variables: { id }
     });
 
-    return parseCampaign((data as any)?.getCampaign);
+    const parsed = parseCampaign((data as any)?.getCampaign);
+    if (!parsed) return 'Failed to parse campaign';
+
+    return parsed;
   } catch (error) {
     console.error('Error fetching campaign:', error);
-    return null;
+    return 'Error fetching campaign';
   }
 };
 
-export const createCampaign = async (campaign: Omit<Campaign, 'id'>): Promise<Campaign | null> => {
+export const createCampaign = async (campaign: Omit<Campaign, 'id'>): Promise<Campaign | string> => {
   try {
     const input = {
       id: uuid.generate(),
       ...campaign
     };
 
-    const { data, errors } = await client.graphql({
+    const result = await client.graphql({
       query: mutations.createCampaign,
       variables: { input }
     });
 
+    const data = (result as any)?.data;
+    const errors = (result as any)?.errors;
+
     if (errors?.length) {
       console.error('GraphQL error(s):', errors);
-      return null;
+      return errors[0]?.message || 'Unknown error creating campaign';
     }
 
-    return parseCampaign((data as any)?.createCampaign);
+    const createdCampaign = parseCampaign(data?.createCampaign);
+    if (!createdCampaign) return 'Failed to parse created campaign';
+
+    return createdCampaign;
   } catch (error) {
     console.error('Error creating campaign:', error);
-    return null;
+    return 'Error creating campaign';
   }
 };
 
-export const updateCampaign = async (id: string, updates: Partial<Campaign>): Promise<boolean> => {
+export const updateCampaign = async (id: string, updates: Partial<Campaign>): Promise<boolean | string> => {
   try {
     const cleanedInput = { ...updates };
 
-    // Strip unwanted fields from campaign-level properties
     delete (cleanedInput as any).createdAt;
     delete (cleanedInput as any).updatedAt;
     delete (cleanedInput as any).owner;
     delete (cleanedInput as any).__typename;
 
-    // 🧼 Clean up sessions array (remove any unexpected fields)
     if (cleanedInput.sessions) {
       cleanedInput.sessions = cleanedInput.sessions.map((s: any) => ({
         id: s.id,
@@ -106,29 +113,38 @@ export const updateCampaign = async (id: string, updates: Partial<Campaign>): Pr
       ...cleanedInput,
     };
 
-    await client.graphql({
+    const result = await client.graphql({
       query: mutations.updateCampaign,
       variables: { input },
     });
 
+    const errors = (result as any)?.errors;
+    if (errors?.length) {
+      return errors[0]?.message || 'Unknown error updating campaign';
+    }
+
     return true;
   } catch (error) {
     console.error('Error updating campaign:', error);
-    return false;
+    return 'Error updating campaign';
   }
 };
 
-
-export const deleteCampaign = async (id: string): Promise<boolean> => {
+export const deleteCampaign = async (id: string): Promise<boolean | string> => {
   try {
-    await client.graphql({
+    const result = await client.graphql({
       query: mutations.deleteCampaign,
       variables: { input: { id } }
     });
 
+    const errors = (result as any)?.errors;
+    if (errors?.length) {
+      return errors[0]?.message || 'Unknown error deleting campaign';
+    }
+
     return true;
   } catch (error) {
     console.error('Error deleting campaign:', error);
-    return false;
+    return 'Error deleting campaign';
   }
 };

src/stores/campaignStore.ts

@@ -7,68 +7,107 @@ import {
   updateCampaign as updateCampaignService,
   deleteCampaign as deleteCampaignService
 } from '@/services/campaignService';
+import { getMap } from '@/services/mapService';
+import { getSteading } from '@/services/steadingService';
+import { getFront } from '@/services/frontService';
 
 export const useCampaignStore = defineStore('campaigns', {
   state: () => ({
     campaigns: [] as Campaign[],
     selectedCampaign: null as Campaign | null,
+    linkedSteadings: [] as any[],
+    linkedFronts: [] as any[],
   }),
   actions: {
-    async fetchCampaigns(userId: string) {
-      try {
-        this.campaigns = await getCampaigns(userId);
-      } catch (error) {
-        console.error('Failed to fetch campaigns', error);
+    async fetchCampaigns(userId: string): Promise<true | string> {
+      const result = await getCampaigns(userId);
+      if (typeof result === 'string') {
+        console.error('Failed to fetch campaigns', result);
+        return result;
       }
+      this.campaigns = result;
+      return true;
     },
 
-    async createCampaign(campaignData: Partial<Campaign>, userId: string) {
-      try {
-        const created = await createCampaignService({
-          ...campaignData,
-          userId
-        } as Omit<Campaign, 'id'>);
+    async createCampaign(campaignData: Partial<Campaign>, userId: string): Promise<true | string> {
+      const result = await createCampaignService({
+        ...campaignData,
+        userId
+      } as Omit<Campaign, 'id'>);
 
-        if (created) {
-          this.campaigns.push(created);
-        }
-      } catch (error) {
-        console.error('Failed to create campaign', error);
+      if (typeof result === 'string') {
+        console.error('Failed to create campaign', result);
+        return result;
       }
+
+      this.campaigns.push(result);
+      return true;
     },
 
-    async updateCampaign(campaignId: string, updates: Partial<Campaign>) {
-      try {
-        const success = await updateCampaignService(campaignId, updates);
-        if (success) {
-          await this.fetchCampaigns(updates.userId!); // assumes userId exists in updates
-        }
-      } catch (error) {
-        console.error('Failed to update campaign', error);
+    async updateCampaign(campaignId: string, updates: Partial<Campaign>): Promise<true | string> {
+      const result = await updateCampaignService(campaignId, updates);
+
+      if (typeof result === 'string') {
+        console.error('Failed to update campaign', result);
+        return result;
       }
+
+      if (updates.userId) {
+        await this.fetchCampaigns(updates.userId);
+      }
+      return true;
     },
 
-    async deleteCampaign(campaignId: string) {
-      try {
-        const success = await deleteCampaignService(campaignId);
-        if (success) {
-          this.campaigns = this.campaigns.filter(c => c.id !== campaignId);
-        }
-      } catch (error) {
-        console.error('Failed to delete campaign', error);
+    async deleteCampaign(campaignId: string): Promise<true | string> {
+      const result = await deleteCampaignService(campaignId);
+      if (typeof result === 'string') {
+        console.error('Failed to delete campaign', result);
+        return result;
       }
+      this.campaigns = this.campaigns.filter(c => c.id !== campaignId);
+      return true;
     },
 
-    async fetchCampaignById(id: string) {
-      try {
-        this.selectedCampaign = await getCampaign(id);
-      } catch (error) {
-        console.error('Failed to fetch campaign by ID', error);
+    async fetchCampaignById(id: string): Promise<true | string> {
+      const result = await getCampaign(id);
+      if (typeof result === 'string') {
+        console.error('Failed to fetch campaign by ID', result);
+        return result;
       }
+      this.selectedCampaign = result;
+      await this.loadLinkedEntities();
+      return true;
+    },
+
+    async loadLinkedEntities() {
+      if (!this.selectedCampaign) return;
+      const mapIds = this.selectedCampaign.mapIds || [];
+
+      const loadedMaps = await Promise.all(mapIds.map(id => getMap(id)));
+
+      const frontIds = new Set<string>();
+      const steadingIds = new Set<string>();
+
+      for (const map of loadedMaps.filter(Boolean)) {
+        const locations = typeof map?.locations === 'string' ? JSON.parse(map.locations) : map?.locations;
+
+        for (const loc of locations || []) {
+          if (loc.steading_id) steadingIds.add(loc.steading_id);
+          if (Array.isArray(loc.fronts)) loc.fronts.forEach((fid: string) => frontIds.add(fid));
+        }
+      }
+
+      const [steadings, fronts] = await Promise.all([
+        Promise.all(Array.from(steadingIds).map(id => getSteading(id))),
+        Promise.all(Array.from(frontIds).map(id => getFront(id)))
+      ]);
+
+      this.linkedSteadings = steadings.filter(Boolean);
+      this.linkedFronts = fronts.filter(Boolean);
     },
 
     selectCampaign(id: string) {
       this.selectedCampaign = this.campaigns.find(c => c.id === id) || null;
     },
   },
-});
+});