flowrix 1.0.1-beta.14 → 1.0.1-beta.141

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;
     }
@@ -55,5 +427,10 @@ export const useAuthStore = defineStore("auth", {
     getToken: (state) => state.token,
     isLoggedIn: (state) => state.isAuthenticated,
     isHydrated: (state) => state._hydrated
+  },
+  persist: {
+    enabled: true,
+    key: "user",
+    storage: typeof window !== "undefined" ? localStorage : void 0
   }
 });

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/countries");
+      this.countries = response;
+      return response;
     }
   }
 });

package/dist/runtime/stores/product/README.md

@@ -89,22 +89,22 @@ await productStore.refreshProduct()
 const productStore = useProductSlugStore()
 
 // Check if product exists
-console.log(productStore.hasProduct)
+// console.log(productStore.hasProduct)
 
 // Get product name safely
-console.log(productStore.productName)
+// console.log(productStore.productName)
 
 // Check if product has discount
-console.log(productStore.hasDiscount)
+// console.log(productStore.hasDiscount)
 
 // Check loading state
-console.log(productStore.isProductLoading)
+// console.log(productStore.isProductLoading)
 
 // Get error message
-console.log(productStore.productError)
+// console.log(productStore.productError)
 
 // Check if product is valid
-console.log(productStore.isValidProduct)
+// console.log(productStore.isValidProduct)
 ```
 
 ## API Endpoint Format

package/dist/runtime/stores/product/slug.d.ts

@@ -155,23 +155,7 @@ export declare const useProductSlugStore: import("pinia").StoreDefinition<"produ
         lastFetchedSlug: string | null;
     } & import("pinia").PiniaCustomStateProperties<ProductSlugState>) => string | null | undefined;
 }, {
-    fetchProductBySlug(slug: string): Promise<{
-        [x: string]: any;
-        id?: string | number | undefined;
-        slug?: string | undefined;
-        name?: string | undefined;
-        description?: string | undefined;
-        price?: string | undefined;
-        rrp?: string | undefined;
-        pricefloat?: number | undefined;
-        rpfloat?: number | undefined;
-        brandimage?: string | undefined;
-        variations?: string | undefined;
-        template?: string | undefined;
-        images?: string[] | undefined;
-        category?: string | undefined;
-        stock?: number | undefined;
-    } | null>;
+    fetchProductBySlug(slug: string): Promise<any>;
     clearProduct(): void;
     clearError(): void;
     updateProduct(updates: Partial<Product>): void;

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

@@ -1,18 +1,33 @@
-export interface WebForm {
+export interface WebFormField {
     id: number;
+    name: string;
+    label: string;
+    type: string;
+    required: boolean;
+    options?: string[];
+    validation?: string;
+    placeholder?: string;
 }
-export interface WebFormData {
+export interface WebForm {
     id: number;
+    title: string;
+    description?: string;
+    fields: WebFormField[];
+    success_message?: string;
+}
+export interface WebFormSubmission {
+    [key: string]: any;
     recaptcha: string;
 }
+export interface WebFormResponse {
+    status: string;
+    message: string;
+    data: any | null;
+}
 export declare const useWebformsStore: import("pinia").StoreDefinition<"webforms", {
     webform: WebForm | null;
-    webFormReturn: any;
+    webFormReturn: WebFormResponse | null;
     loading: boolean;
     error: string | null;
-}, {}, {
-    setWebform(webform: WebForm | null): void;
-    setWebFormReturn(returnValue: any): void;
-    setLoading(loading: boolean): void;
-    setError(error: string | null): void;
-}>;
+    _hydrated: boolean;
+}, {}, {}>;

package/dist/runtime/stores/webforms.js

@@ -1,23 +1,123 @@
 import { defineStore } from "pinia";
+import { flowrixApi } from "../middleware/flowrix.js";
+import { useRuntimeConfig } from "#imports";
+function formatErrorMessage(message) {
+  if (typeof message === "string") {
+    return message;
+  }
+  if (Array.isArray(message)) {
+    return message.join(", ");
+  }
+  const errorMessages = [];
+  for (const [field, errors] of Object.entries(message)) {
+    if (Array.isArray(errors)) {
+      errorMessages.push(...errors);
+    } else {
+      errorMessages.push(String(errors));
+    }
+  }
+  return errorMessages.join(", ");
+}
 export const useWebformsStore = defineStore("webforms", {
   state: () => ({
     webform: null,
     webFormReturn: null,
     loading: false,
-    error: null
+    error: null,
+    _hydrated: false
   }),
   actions: {
+    async fetchWebform(id) {
+      try {
+        this.loading = true;
+        this.error = null;
+        const config = useRuntimeConfig();
+        let rawCookies = "";
+        if (process.client) {
+          rawCookies = document.cookie || "";
+        }
+        const apiConfig = {
+          ...config,
+          cookies: rawCookies
+        };
+        const apiUrl = `contact-center/webforms/${id}/details`;
+        const response = await flowrixApi.get(apiUrl, apiConfig);
+        if (response.status === "Success" && response.data) {
+          this.webform = response.data;
+          return response.data;
+        }
+        return null;
+      } catch (error) {
+        console.error("Fetch webform failed:", error);
+        this.error = error.data ? formatErrorMessage(error.data.message) : error.message || "Failed to fetch webform";
+        return null;
+      } finally {
+        this.loading = false;
+      }
+    },
+    async submitInquiry(formData) {
+      try {
+        this.loading = true;
+        this.error = null;
+        const config = useRuntimeConfig();
+        let rawCookies = "";
+        if (process.client) {
+          rawCookies = document.cookie || "";
+        }
+        const apiConfig = {
+          ...config,
+          cookies: rawCookies
+        };
+        const apiUrl = "contact-center/webforms/create";
+        const response = await flowrixApi.post(apiUrl, apiConfig, {
+          body: formData
+        });
+        if (response.status === "Success") {
+          this.webFormReturn = response;
+          return response;
+        } else {
+          const errorMessage = response.message || "Failed to submit inquiry";
+          throw new Error(errorMessage);
+        }
+      } catch (error) {
+        console.error("Submit inquiry error:", error);
+        const message = error.data ? formatErrorMessage(error.data.message) : error.message || "Submission failed";
+        this.error = message;
+        return {
+          status: "Error",
+          message,
+          data: null
+        };
+      } finally {
+        this.loading = false;
+      }
+    },
     setWebform(webform) {
       this.webform = webform;
     },
     setWebFormReturn(returnValue) {
       this.webFormReturn = returnValue;
     },
-    setLoading(loading) {
-      this.loading = loading;
+    clearError() {
+      this.error = null;
+    },
+    clearWebFormReturn() {
+      this.webFormReturn = null;
     },
-    setError(error) {
-      this.error = error;
+    setHydrated() {
+      this._hydrated = true;
     }
+  },
+  getters: {
+    getWebform: (state) => state.webform,
+    getWebFormReturn: (state) => state.webFormReturn,
+    getLoading: (state) => state.loading,
+    getError: (state) => state.error,
+    isHydrated: (state) => state._hydrated
+  },
+  persist: {
+    enabled: true,
+    key: "webforms",
+    storage: typeof window !== "undefined" ? localStorage : void 0
   }
 });