flowrix 1.0.1-beta.14 → 1.0.1-beta.140

package/dist/runtime/stores/Checkout.js

@@ -1,6 +1,7 @@
 import { useCartStore } from "./Cart.js";
 import { defineStore } from "pinia";
-import { useApi } from "../utils/api.js";
+import { flowrixApi } from "../middleware/flowrix.js";
+import { useRuntimeConfig } from "#imports";
 export const useCheckoutStore = defineStore("checkout", {
   state: () => ({
     publishableKey: {},
@@ -62,7 +63,6 @@ export const useCheckoutStore = defineStore("checkout", {
     },
     async getConfig() {
       try {
-        const { post } = useApi();
         const formData = this.checkoutSession.fields || this.checkoutSession;
         if (formData.cart && Object.keys(formData.cart).length > 0) {
           const samples = Object.keys(formData.cart).filter(
@@ -78,10 +78,26 @@ export const useCheckoutStore = defineStore("checkout", {
         if (useCartStore().coupon?.length > 0) {
           formData.vouchercodes = useCartStore().coupon;
         }
-        formData.cart = useCartStore().cart.items;
+        if (useCartStore().cart.items != void 0 && Object.keys(useCartStore().cart.items).length > 0) {
+          formData.cart = useCartStore().cart.items;
+        } else {
+          delete formData.cart;
+        }
         formData.abndToken = useCartStore().cart.abndToken;
         const apiUrl = `checkout/configs`;
-        const response = await post(apiUrl, formData);
+        const config = useRuntimeConfig();
+        const rawCookies = document.cookie;
+        const apiConfig = {
+          ...config,
+          cookies: rawCookies
+        };
+        const response = await flowrixApi.post(
+          apiUrl,
+          apiConfig,
+          {
+            body: formData
+          }
+        );
         if (response?.data) {
           this.config = response.data;
           const shippingMethods = response.data.shippingmethods;
@@ -104,12 +120,14 @@ export const useCheckoutStore = defineStore("checkout", {
               deliverymethod: deliveryMethod.id
             };
           }
-          const cart = {
+          let cart = {
             items: response.data.cart,
-            totals: response.data.calculations
+            totals: response.data.calculations,
+            quote_items: response.data.quote_items || []
           };
           useCartStore().cart.items = cart.items;
           useCartStore().cart.totals = cart.totals;
+          useCartStore().cart.quote_items = cart.quote_items;
           this.config.totals = response.data.calculations;
           this.checkoutSession.calculations = response.data.calculations;
         }
@@ -120,11 +138,13 @@ export const useCheckoutStore = defineStore("checkout", {
     async submitCheckout() {
       try {
         this.loading = true;
-        const { post } = useApi();
         const formData = this.checkoutSession.fields || {};
         const apiUrl = `customer/checkout`;
         formData.billing_address2 = formData.billing_address;
-        const response = await post(apiUrl, formData);
+        delete formData.fields;
+        delete formData.calculations;
+        const config = useRuntimeConfig();
+        const response = await flowrixApi.post(apiUrl, config, { body: formData });
         if (response?.data?.order || response?.data?.order_no) {
           const orderData = response.data.order || response.data;
           const invoiceId = orderData.order_no;
@@ -148,28 +168,15 @@ export const useCheckoutStore = defineStore("checkout", {
           invoice: error?.data?.data?.order_no
         };
         this.loading = false;
-        return error;
-      }
-    },
-    async confirmPayment(checkoutId) {
-      try {
-        const apiUrl = `/api/checkout/success`;
-        await $fetch(apiUrl, {
-          method: "POST",
-          body: { token: checkoutId }
-        });
-      } catch (error) {
-        console.error("Error confirming payment:", error);
+        return error.data;
       }
     },
     async CheckUserAccount(email) {
       try {
         this.loading = true;
-        const apiUrl = `/api/customer/search`;
-        const response = await $fetch(apiUrl, {
-          method: "POST",
-          body: { email }
-        });
+        const apiUrl = `customers/search`;
+        const config = useRuntimeConfig();
+        const response = await flowrixApi.post(apiUrl, config, { body: { email } });
         this.checkCustomer = response;
         this.loading = false;
         return response;
@@ -180,25 +187,6 @@ export const useCheckoutStore = defineStore("checkout", {
       }
     },
     async saveToCheckoutSession(fieldsData) {
-      this.loading = true;
-      fieldsData.firstname = fieldsData.billing_firstname ?? void 0;
-      fieldsData.lastname = fieldsData.billing_lastname ?? void 0;
-      fieldsData.mobile = fieldsData.billing_mobile ?? void 0;
-      fieldsData.fullname = `${fieldsData.billing_firstname} ${fieldsData.billing_lastname}`;
-      fieldsData.billing_fullname = `${fieldsData.billing_firstname} ${fieldsData.billing_lastname}`;
-      fieldsData.shipping_fullname = `${fieldsData.billing_firstname} ${fieldsData.billing_lastname}`;
-      if (fieldsData.shippingasbilling === true) {
-        fieldsData.billing_address = fieldsData.shipping_address ?? void 0;
-        fieldsData.billing_country = fieldsData.shipping_country ?? null;
-        fieldsData.billing_state = fieldsData.shipping_state ?? void 0;
-        fieldsData.billing_suburb = fieldsData.shipping_suburb ?? void 0;
-        fieldsData.billing_firstname = fieldsData.shipping_firstname ?? void 0;
-        fieldsData.billing_fullname = fieldsData.shipping_fullname ?? null;
-        fieldsData.billing_lastname = fieldsData.shipping_lastname ?? void 0;
-        fieldsData.billing_middlename = fieldsData.shipping_middlename ?? void 0;
-        fieldsData.billing_mobile = fieldsData.shipping_mobile ?? void 0;
-        fieldsData.billing_postcode = fieldsData.shipping_postcode ?? void 0;
-      }
       this.checkoutSession.fields = {
         ...this.checkoutSession.fields,
         ...fieldsData
@@ -209,5 +197,10 @@ export const useCheckoutStore = defineStore("checkout", {
       }
     }
   },
-  persist: true
+  persist: {
+    enabled: true,
+    // simple shape that works with most versions:
+    key: "checkoutSession",
+    storage: typeof window !== "undefined" ? localStorage : void 0
+  }
 });

package/dist/runtime/stores/IpLocation.d.ts

@@ -1,4 +1,4 @@
-interface LocationData {
+export interface LocationData {
     city?: string;
     country_name?: string;
     country_code?: string;
@@ -10,9 +10,100 @@ interface LocationData {
     region_id?: number;
     zip_code?: string;
 }
+export interface LocationResponse {
+    status: string;
+    message?: string;
+    data: LocationData | null;
+}
 export declare const useIpLocation: import("pinia").StoreDefinition<"IpLocation", {
     location: LocationData | null;
-}, {}, {
-    getLocation(): Promise<void>;
+    loading: boolean;
+    error: string | null;
+}, {
+    hasLocation: (state: {
+        location: {
+            city?: string | undefined;
+            country_name?: string | undefined;
+            country_code?: string | undefined;
+            country_id?: number | undefined;
+            ip?: string | undefined;
+            proxy?: boolean | undefined;
+            region?: string | undefined;
+            region_short?: string | undefined;
+            region_id?: number | undefined;
+            zip_code?: string | undefined;
+        } | null;
+        loading: boolean;
+        error: string | null;
+    } & import("pinia").PiniaCustomStateProperties<{
+        location: LocationData | null;
+        loading: boolean;
+        error: string | null;
+    }>) => boolean;
+    isLoading: (state: {
+        location: {
+            city?: string | undefined;
+            country_name?: string | undefined;
+            country_code?: string | undefined;
+            country_id?: number | undefined;
+            ip?: string | undefined;
+            proxy?: boolean | undefined;
+            region?: string | undefined;
+            region_short?: string | undefined;
+            region_id?: number | undefined;
+            zip_code?: string | undefined;
+        } | null;
+        loading: boolean;
+        error: string | null;
+    } & import("pinia").PiniaCustomStateProperties<{
+        location: LocationData | null;
+        loading: boolean;
+        error: string | null;
+    }>) => boolean;
+    locationString: (state: {
+        location: {
+            city?: string | undefined;
+            country_name?: string | undefined;
+            country_code?: string | undefined;
+            country_id?: number | undefined;
+            ip?: string | undefined;
+            proxy?: boolean | undefined;
+            region?: string | undefined;
+            region_short?: string | undefined;
+            region_id?: number | undefined;
+            zip_code?: string | undefined;
+        } | null;
+        loading: boolean;
+        error: string | null;
+    } & import("pinia").PiniaCustomStateProperties<{
+        location: LocationData | null;
+        loading: boolean;
+        error: string | null;
+    }>) => string;
+    fullAddress: (state: {
+        location: {
+            city?: string | undefined;
+            country_name?: string | undefined;
+            country_code?: string | undefined;
+            country_id?: number | undefined;
+            ip?: string | undefined;
+            proxy?: boolean | undefined;
+            region?: string | undefined;
+            region_short?: string | undefined;
+            region_id?: number | undefined;
+            zip_code?: string | undefined;
+        } | null;
+        loading: boolean;
+        error: string | null;
+    } & import("pinia").PiniaCustomStateProperties<{
+        location: LocationData | null;
+        loading: boolean;
+        error: string | null;
+    }>) => string;
+}, {
+    getLocation(): Promise<LocationData | null>;
+    setLocation(locationData: LocationData): void;
+    updateLocation(partialData: Partial<LocationData>): void;
+    clearLocation(): void;
+    clearError(): void;
 }>;
-export {};

package/dist/runtime/stores/IpLocation.js

@@ -1,29 +1,107 @@
 import { defineStore } from "pinia";
+import { flowrixApi } from "../middleware/flowrix.js";
+import { useRuntimeConfig } from "#imports";
+function formatErrorMessage(message) {
+  if (Array.isArray(message)) {
+    return message.join(", ");
+  }
+  return message;
+}
 export const useIpLocation = defineStore("IpLocation", {
   state: () => ({
-    location: null
+    location: null,
+    loading: false,
+    error: null
   }),
+  getters: {
+    hasLocation: (state) => state.location !== null,
+    isLoading: (state) => state.loading,
+    locationString: (state) => {
+      if (!state.location) return "";
+      const parts = [
+        state.location.city,
+        state.location.region_short || state.location.region,
+        state.location.zip_code
+      ].filter(Boolean);
+      return parts.join(", ");
+    },
+    fullAddress: (state) => {
+      if (!state.location) return "";
+      const parts = [
+        state.location.city,
+        state.location.region,
+        state.location.zip_code,
+        state.location.country_name
+      ].filter(Boolean);
+      return parts.join(", ");
+    }
+  },
   actions: {
     async getLocation() {
+      if (this.loading || this.location !== null) {
+        console.log("Location already loaded or loading:", this.location);
+        return this.location;
+      }
+      this.loading = true;
+      this.error = null;
       try {
-        if (this.location == null) {
-          const response = await $fetch(`/api/location`, {
-            method: "POST",
-            headers: {
-              "Content-Type": "application/json"
-            }
-          });
-          if (response.status == "Success" && response.data != null) {
-            this.location = response.data;
-          } else {
-            this.location = null;
-          }
+        const config = useRuntimeConfig();
+        let rawCookies = "";
+        if (process.client) {
+          rawCookies = document.cookie || "";
+        }
+        const apiConfig = {
+          ...config,
+          cookies: rawCookies
+        };
+        const apiUrl = "location";
+        const response = await flowrixApi.post(apiUrl, apiConfig);
+        if (response.status === "Success" && response.data !== null) {
+          this.location = response.data;
+          console.log("Location loaded:", this.location);
+          return response.data;
+        } else {
+          const errorMessage = response.message ? formatErrorMessage(response.message) : "Failed to fetch location";
+          this.error = errorMessage;
+          console.error("Failed to fetch location:", errorMessage);
+          this.location = null;
+          return null;
         }
       } catch (error) {
-        console.error("Error fetching data:", error);
+        console.error("Error fetching location:", error);
+        this.error = error.message || "Unknown error occurred";
         this.location = null;
+        return null;
+      } finally {
+        this.loading = false;
+      }
+    },
+    setLocation(locationData) {
+      this.location = locationData;
+      this.error = null;
+      console.log("Location set manually:", this.location);
+    },
+    updateLocation(partialData) {
+      if (this.location) {
+        this.location = { ...this.location, ...partialData };
+        console.log("Location updated:", this.location);
+      } else {
+        console.warn("Cannot update location: no location data exists");
       }
+    },
+    clearLocation() {
+      this.location = null;
+      this.error = null;
+      this.loading = false;
+      console.log("Location cleared");
+    },
+    clearError() {
+      this.error = null;
     }
   },
-  persist: true
+  persist: {
+    key: "IpLocation",
+    storage: typeof window !== "undefined" ? localStorage : void 0,
+    paths: ["location"]
+  }
 });

package/dist/runtime/stores/Search.d.ts

@@ -1,5 +1,5 @@
 export declare const useSearchStore: import("pinia").StoreDefinition<"SearchStore", {
     data: any[];
 }, {}, {
-    fetchSearchData(query: string): Promise<any[]>;
+    fetchSearchData(query: string): Promise<any>;
 }>;

package/dist/runtime/stores/Services.d.ts

@@ -1,7 +1,12 @@
 export declare const useServiceStore: import("pinia").StoreDefinition<"ServiceStore", {
     services: never[];
+    currentService: any | null;
     availability: boolean;
+    loading: boolean;
+    error: string | null;
 }, {}, {
     getAllServices(): Promise<void>;
+    getServiceBySlug(slug: string, query?: {}): Promise<any>;
     checkAvailability(data: any): Promise<any>;
+    clearCurrentService(): void;
 }>;

package/dist/runtime/stores/Services.js

@@ -1,16 +1,21 @@
 import { defineStore } from "pinia";
+import { flowrixApi } from "../middleware/flowrix.js";
+import { useRuntimeConfig } from "#imports";
 import { useCheckoutStore } from "./Checkout.js";
 export const useServiceStore = defineStore("ServiceStore", {
   state: () => ({
     services: [],
-    availability: false
+    currentService: null,
+    availability: false,
+    loading: false,
+    error: null
   }),
   actions: {
     async getAllServices() {
       try {
-        const apiUrl = `/api/services/getall`;
+        const apiUrl = `/api/service/getall`;
         const response = await $fetch(apiUrl, {
-          method: "GET",
+          method: "POST",
           headers: {
             "Content-Type": "application/json"
           }
@@ -24,26 +29,72 @@ export const useServiceStore = defineStore("ServiceStore", {
         console.error("Error fetching data:", error);
       }
     },
-    async checkAvailability(data) {
+    async getServiceBySlug(slug, query = {}) {
+      this.loading = true;
+      this.error = null;
       try {
-        const apiUrl = `/api/services/availability`;
+        const apiUrl = `/api/service/${slug}`;
         const response = await $fetch(apiUrl, {
           method: "POST",
           headers: {
             "Content-Type": "application/json"
           },
+          query,
+          body: {}
+        });
+        if (response.status === "Success" && response.data) {
+          this.currentService = response.data;
+          return response.data;
+        } else if (response.success !== false && !response.status) {
+          this.currentService = response;
+          return response;
+        } else {
+          this.error = response.message || response.error || "Failed to fetch service";
+          return null;
+        }
+      } catch (error) {
+        console.error("Error fetching service by slug:", error);
+        this.error = error.message || "Failed to fetch service";
+        return null;
+      } finally {
+        this.loading = false;
+      }
+    },
+    async checkAvailability(data) {
+      this.loading = true;
+      this.error = null;
+      try {
+        const config = useRuntimeConfig();
+        let rawCookies = "";
+        if (process.client) {
+          rawCookies = document.cookie || "";
+        }
+        const apiConfig = {
+          ...config,
+          cookies: rawCookies
+        };
+        const apiUrl = "services/availability";
+        const response = await flowrixApi.post(apiUrl, apiConfig, {
           body: data
         });
-        if (response.status == "Success") {
+        if (response.status === "Success") {
           this.availability = response.data.service;
           useCheckoutStore().saveToCheckoutSession(data);
           return response.data;
         } else {
-          this.data = null;
+          this.error = response.message || "Failed to check availability";
+          return null;
         }
       } catch (error) {
-        console.error("Error fetching data:", error);
+        console.error("Error checking availability:", error);
+        this.error = error.message || "Failed to check availability";
+        return null;
+      } finally {
+        this.loading = false;
       }
+    },
+    clearCurrentService() {
+      this.currentService = null;
     }
   }
 });

package/dist/runtime/stores/auth.d.ts

@@ -43,20 +43,17 @@ export interface User {
 export interface AuthState {
     user: User | null;
     token: string | null;
-    isAuthenticated: boolean;
-    _hydrated: boolean;
+    isAuthenticated: false;
+    _hydrated: false;
+}
+export interface AuthResponse {
+    status: string;
+    message: string;
+    data: any | null;
 }
 export declare const useAuthStore: import("pinia").StoreDefinition<"auth", AuthState, {
     getUser: (state: AuthState) => User | null;
     getToken: (state: AuthState) => string | null;
     isLoggedIn: (state: AuthState) => boolean;
     isHydrated: (state: AuthState) => boolean;
-}, {
-    setAuth({ user, token }: {
-        user: User;
-        token: string;
-    }): void;
-    loadAuth(): void;
-    logout(): void;
-    setHydrated(): void;
-}>;
+}, {}>;