flowrix 1.0.1-beta.16 → 1.0.1-beta.160

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/Search.js

@@ -1,4 +1,5 @@
-import { useApi } from "../utils/api.js";
+import { flowrixApi } from "../middleware/flowrix.js";
+import { useRuntimeConfig } from "#imports";
 import { defineStore } from "pinia";
 export const useSearchStore = defineStore("SearchStore", {
   state: () => ({
@@ -6,7 +7,12 @@ export const useSearchStore = defineStore("SearchStore", {
   }),
   actions: {
     async fetchSearchData(query) {
-      const { get } = useApi();
+      const config = useRuntimeConfig();
+      let rawCookies = "";
+      if (process.client) {
+        rawCookies = document.cookie || "";
+      }
+      const apiConfig = { ...config, cookies: rawCookies };
       try {
         this.data = [];
         const params = new URLSearchParams();
@@ -15,7 +21,7 @@ export const useSearchStore = defineStore("SearchStore", {
         params.append("ProductType[]", "simple");
         params.append("ProductType[]", "bundle");
         const apiUrl = `search?${params.toString()}`;
-        const response = await get(apiUrl);
+        const response = await flowrixApi.get(apiUrl, apiConfig);
         if (response?.status === "Success" && Array.isArray(response.data.products.data)) {
           this.data = response.data.products.data;
           return this.data;

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,8 +43,13 @@ 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;
@@ -52,10 +57,29 @@ export declare const useAuthStore: import("pinia").StoreDefinition<"auth", AuthS
     isLoggedIn: (state: AuthState) => boolean;
     isHydrated: (state: AuthState) => boolean;
 }, {
-    setAuth({ user, token }: {
-        user: User;
-        token: string;
-    }): void;
+    userLogin(userFields: any): Promise<any>;
+    signUp(userFields: any): Promise<any>;
+    fetchProfile(): Promise<User | null>;
+    updateProfile(userData: any): Promise<{
+        status: string;
+        message: string;
+    }>;
+    fetchUserCards(): Promise<User | null>;
+    changePassword(userData: any): Promise<any>;
+    deleteCard(cardId: string): Promise<{
+        status: string;
+        message: string;
+    }>;
+    fetchOrders(): Promise<User | null>;
+    downloadInvoice(orderNo: string): Promise<void>;
+    fetchQuotations(): Promise<User | null>;
+    setAddress(addressData: any, method?: string): Promise<{
+        status: string;
+        message: string;
+    }>;
+    verifyEmail(email: string): Promise<AuthResponse>;
+    verifyToken(email: string, token: string): Promise<AuthResponse>;
+    resetPassword(token: string, password: string, password_confirmation: string): Promise<AuthResponse>;
     loadAuth(): void;
     logout(): void;
     setHydrated(): void;

package/dist/runtime/stores/auth.js

@@ -1,4 +1,12 @@
 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 useAuthStore = defineStore("auth", {
   state: () => ({
     user: null,
@@ -7,13 +15,376 @@ export const useAuthStore = defineStore("auth", {
     _hydrated: false
   }),
   actions: {
-    setAuth({ user, token }) {
-      this.user = user;
-      this.token = token;
-      this.isAuthenticated = true;
-      if (process.client) {
-        localStorage.setItem("auth_token", token);
-        localStorage.setItem("auth_user", JSON.stringify(user));
+    async userLogin(userFields) {
+      try {
+        this.user = null;
+        const apiUrl = "login";
+        const config = useRuntimeConfig();
+        let rawCookies = "";
+        if (process.client) {
+          rawCookies = document.cookie || "";
+        }
+        const apiConfig = {
+          ...config,
+          cookies: rawCookies
+        };
+        const response = await flowrixApi.post(apiUrl, apiConfig, {
+          body: userFields
+        });
+        if (response.status == "Success") {
+          if (process.client) {
+            const token = response?.data?.access_token;
+            const customertype = response?.data?.user?.customertype?.id || 1;
+            const expiryDate = /* @__PURE__ */ new Date();
+            expiryDate.setFullYear(expiryDate.getFullYear() + 100);
+            document.cookie = `authToken=${token}; path=/; expires=${expiryDate.toUTCString()}; SameSite=None; Secure`;
+            document.cookie = `customertype=${customertype}; path=/; expires=${expiryDate.toUTCString()}; SameSite=None; Secure`;
+          }
+          this.token = response.data.access_token;
+          this.user = response.data.user;
+          this.isAuthenticated = true;
+        }
+        return response;
+      } catch (error) {
+        console.error("Login error:", error);
+        return error.data || {
+          status: "Error",
+          message: "Login failed. Please try again."
+        };
+      }
+    },
+    async signUp(userFields) {
+      try {
+        this.user = null;
+        const apiUrl = "mystore/customer/create";
+        const config = useRuntimeConfig();
+        let rawCookies = "";
+        if (process.client) {
+          rawCookies = document.cookie || "";
+        }
+        const apiConfig = {
+          ...config,
+          cookies: rawCookies
+        };
+        const response = await flowrixApi.post(apiUrl, apiConfig, {
+          body: userFields
+        });
+        if (response.status == "Success") {
+          return response;
+        }
+        return response;
+      } catch (error) {
+        console.error("Signup error:", error);
+        return error.data || {
+          status: "Error",
+          message: "Registration failed. Please try again."
+        };
+      }
+    },
+    async fetchProfile() {
+      try {
+        const config = useRuntimeConfig();
+        let rawCookies = "";
+        if (process.client) {
+          rawCookies = document.cookie || "";
+        }
+        const apiConfig = {
+          ...config,
+          cookies: rawCookies
+        };
+        const apiUrl = "mystore/customer/profile";
+        const response = await flowrixApi.get(apiUrl, apiConfig);
+        if (response.status === "Success" && response.data) {
+          this.user = response.data;
+          return response.data;
+        }
+        return null;
+      } catch (error) {
+        console.error("Fetch profile failed:", error);
+        return null;
+      }
+    },
+    async updateProfile(userData) {
+      try {
+        const config = useRuntimeConfig();
+        let rawCookies = "";
+        if (process.client) {
+          rawCookies = document.cookie || "";
+        }
+        const apiConfig = {
+          ...config,
+          cookies: rawCookies
+        };
+        const apiUrl = "mystore/customer/profile/update";
+        const response = await flowrixApi.post(apiUrl, apiConfig, {
+          body: userData
+        });
+        if (response.status === "Success") {
+          await this.fetchProfile();
+          return { status: response.status, message: response.message || "Profile Updated Successfully" };
+        } else {
+          const errorMessage = response.message;
+          throw new Error(errorMessage);
+        }
+      } catch (error) {
+        return error.data;
+      }
+    },
+    async fetchUserCards() {
+      try {
+        const config = useRuntimeConfig();
+        let rawCookies = "";
+        if (process.client) {
+          rawCookies = document.cookie || "";
+        }
+        const apiConfig = {
+          ...config,
+          cookies: rawCookies
+        };
+        const apiUrl = "mystore/customer/cards";
+        const response = await flowrixApi.get(apiUrl, apiConfig);
+        if (response.status === "Success" && response.data) {
+          this.user = response.data;
+          return response.data;
+        }
+        return null;
+      } catch (error) {
+        console.error("Fetch user cards failed:", error);
+        return null;
+      }
+    },
+    async changePassword(userData) {
+      try {
+        const config = useRuntimeConfig();
+        let rawCookies = "";
+        if (process.client) {
+          rawCookies = document.cookie || "";
+        }
+        const apiConfig = {
+          ...config,
+          cookies: rawCookies
+        };
+        const apiUrl = "mystore/customer/change-password";
+        const response = await flowrixApi.post(apiUrl, apiConfig, {
+          body: userData
+        });
+        return response;
+      } catch (error) {
+        console.error("Change password error:", error);
+        return error.data || error;
+      }
+    },
+    async deleteCard(cardId) {
+      try {
+        const config = useRuntimeConfig();
+        let rawCookies = "";
+        if (process.client) {
+          rawCookies = document.cookie || "";
+        }
+        const apiConfig = {
+          ...config,
+          cookies: rawCookies
+        };
+        const apiUrl = `mystore/customer/cards/${cardId}`;
+        const response = await flowrixApi.delete(apiUrl, apiConfig);
+        if (response.status === "Success") {
+          return { status: response.status, message: response.message || "Card deleted Successfully" };
+        } else {
+          const errorMessage = response.message;
+          throw new Error(errorMessage);
+        }
+      } catch (error) {
+        return error.data;
+      }
+    },
+    async fetchOrders() {
+      try {
+        const config = useRuntimeConfig();
+        let rawCookies = "";
+        if (process.client) {
+          rawCookies = document.cookie || "";
+        }
+        const apiConfig = {
+          ...config,
+          cookies: rawCookies
+        };
+        const apiUrl = "mystore/customer/orders";
+        const response = await flowrixApi.get(apiUrl, apiConfig);
+        if (response.status === "Success" && response.data) {
+          return response.data;
+        }
+        return null;
+      } catch (error) {
+        console.error("Fetch Orders failed:", error);
+        return null;
+      }
+    },
+    async downloadInvoice(orderNo) {
+      try {
+        const config = useRuntimeConfig();
+        let rawCookies = "";
+        if (process.client) {
+          rawCookies = document.cookie || "";
+        }
+        const apiConfig = {
+          ...config,
+          cookies: rawCookies
+        };
+        const apiUrl = `mystore/customer/orders/${orderNo}/tax-invoice`;
+        const response = await flowrixApi.get(apiUrl, apiConfig);
+        const blob = new Blob([response], { type: "application/pdf" });
+        const url = window.URL.createObjectURL(blob);
+        const link = document.createElement("a");
+        link.href = url;
+        link.setAttribute("download", `tax-invoice-${orderNo}.pdf`);
+        document.body.appendChild(link);
+        link.click();
+        document.body.removeChild(link);
+        window.URL.revokeObjectURL(url);
+        return response;
+      } catch (err) {
+        console.error("Download invoice error:", err);
+        return err.data;
+      }
+    },
+    async fetchQuotations() {
+      try {
+        const config = useRuntimeConfig();
+        let rawCookies = "";
+        if (process.client) {
+          rawCookies = document.cookie || "";
+        }
+        const apiConfig = {
+          ...config,
+          cookies: rawCookies
+        };
+        const apiUrl = "mystore/customer/quotations";
+        const response = await flowrixApi.get(apiUrl, apiConfig);
+        if (response.status === "Success" && response.data) {
+          return response.data;
+        }
+        return null;
+      } catch (error) {
+        console.error("Fetch quotations failed:", error);
+        return null;
+      }
+    },
+    async setAddress(addressData, method = "add") {
+      try {
+        const config = useRuntimeConfig();
+        let rawCookies = "";
+        if (process.client) {
+          rawCookies = document.cookie || "";
+        }
+        const apiConfig = {
+          ...config,
+          cookies: rawCookies
+        };
+        let response = {};
+        if (method == "update") {
+          const apiUrl = `mystore/customer/address/${addressData.id}/update`;
+          response = await flowrixApi.patch(apiUrl, apiConfig, {
+            body: addressData
+          });
+        } else if (method == "delete") {
+          const apiUrl = `mystore/customer/address/${addressData.id}/delete`;
+          response = await flowrixApi.patch(apiUrl, apiConfig);
+        } else if (method == "setshipping") {
+          const apiUrl = `mystore/customer/address/${addressData.id}/setshipping`;
+          response = await flowrixApi.post(apiUrl, apiConfig);
+        } else {
+          const apiUrl = "mystore/customer/address/add";
+          response = await flowrixApi.post(apiUrl, apiConfig, {
+            body: addressData
+          });
+        }
+        if (response.status === "Success") {
+          await this.fetchProfile();
+          return response;
+        } else {
+          return response;
+        }
+      } catch (error) {
+        return error.data;
+      }
+    },
+    async verifyEmail(email) {
+      try {
+        const config = useRuntimeConfig();
+        let rawCookies = "";
+        if (process.client) {
+          rawCookies = document.cookie || "";
+        }
+        const apiConfig = {
+          ...config,
+          cookies: rawCookies
+        };
+        const response = await flowrixApi.post("verify-email", apiConfig, {
+          body: { email }
+        });
+        return response;
+      } catch (error) {
+        console.error("Verify email error:", error);
+        const message = error.data ? formatErrorMessage(error.data.message) : error.message || "Email verification failed";
+        return {
+          status: "Error",
+          message,
+          data: null
+        };
+      }
+    },
+    async verifyToken(email, token) {
+      try {
+        const config = useRuntimeConfig();
+        let rawCookies = "";
+        if (process.client) {
+          rawCookies = document.cookie || "";
+        }
+        const apiConfig = {
+          ...config,
+          cookies: rawCookies
+        };
+        const response = await flowrixApi.post("verify-token", apiConfig, {
+          body: { email, token }
+        });
+        return response;
+      } catch (error) {
+        console.error("Verify token error:", error);
+        const message = error.data ? formatErrorMessage(error.data.message) : error.message || "Token verification failed";
+        return {
+          status: "Error",
+          message,
+          data: null
+        };
+      }
+    },
+    async resetPassword(token, password, password_confirmation) {
+      try {
+        const config = useRuntimeConfig();
+        let rawCookies = "";
+        if (process.client) {
+          rawCookies = document.cookie || "";
+        }
+        const apiConfig = {
+          ...config,
+          cookies: rawCookies
+        };
+        const response = await flowrixApi.post("reset-password", apiConfig, {
+          body: {
+            token,
+            password,
+            password_confirmation
+          }
+        });
+        return response;
+      } catch (error) {
+        console.error("Reset password error:", error);
+        const message = error.data ? formatErrorMessage(error.data.message) : error.message || "Password reset failed";
+        return {
+          status: "Error",
+          message,
+          data: null
+        };
       }
     },
     loadAuth() {
@@ -43,9 +414,10 @@ export const useAuthStore = defineStore("auth", {
       if (process.client) {
         localStorage.removeItem("auth_token");
         localStorage.removeItem("auth_user");
+        document.cookie = "authToken=; path=/; expires=Thu, 01 Jan 1970 00:00:00 UTC; SameSite=None; Secure";
+        document.cookie = "customertype=; path=/; expires=Thu, 01 Jan 1970 00:00:00 UTC; SameSite=None; Secure";
       }
     },
-    // Mark as hydrated without loading
     setHydrated() {
       this._hydrated = true;
     }

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

@@ -4,7 +4,5 @@ export declare const useCountriesStore: import("pinia").StoreDefinition<"countri
     loading: boolean;
     error: string | null;
 }, {}, {
-    setCountries(countries: Country[]): void;
-    setLoading(loading: boolean): void;
-    setError(error: string | null): void;
+    getCountries(): Promise<any>;
 }>;

package/dist/runtime/stores/countries.js

@@ -6,14 +6,10 @@ export const useCountriesStore = defineStore("countries", {
     error: null
   }),
   actions: {
-    setCountries(countries) {
-      this.countries = countries;
-    },
-    setLoading(loading) {
-      this.loading = loading;
-    },
-    setError(error) {
-      this.error = error;
+    async getCountries() {
+      const response = await $fetch("/api/global/countries");
+      this.countries = response;
+      return response;
     }
   }
 });

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

@@ -9,7 +9,6 @@ export * from './Categories.js';
 export * from './Checkout.js';
 export * from './compareStore.js';
 export * from './countries.js';
-export * from './IpLocation.js';
 export * from './locations.js';
 export * from './NavMenu.js';
 export * from './orders.js';

package/dist/runtime/stores/index.js

@@ -7,7 +7,6 @@ export * from "./Categories.js";
 export * from "./Checkout.js";
 export * from "./compareStore.js";
 export * from "./countries.js";
-export * from "./IpLocation.js";
 export * from "./locations.js";
 export * from "./NavMenu.js";
 export * from "./orders.js";

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

@@ -4,8 +4,4 @@ export declare const useLocationsStore: import("pinia").StoreDefinition<"locatio
     location: LocationData | null;
     loading: boolean;
     error: string | null;
-}, {}, {
-    setLocation(location: LocationData | null): void;
-    setLoading(loading: boolean): void;
-    setError(error: string | null): void;
-}>;
+}, {}, {}>;

package/dist/runtime/stores/locations.js

@@ -9,11 +9,14 @@ export const useLocationsStore = defineStore("locations", {
     setLocation(location) {
       this.location = location;
     },
-    setLoading(loading) {
-      this.loading = loading;
-    },
-    setError(error) {
-      this.error = error;
+    getLocation(location) {
+      return this.location;
     }
+  },
+  persist: {
+    enabled: true,
+    // simple shape that works with most versions:
+    key: "location",
+    storage: typeof window !== "undefined" ? localStorage : void 0
   }
 });