flowrix 1.0.1-beta.9 → 1.0.1-beta.91

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,383 @@ 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) {
+        return error.data;
+      }
+    },
+    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") {
+          const authTokenCookie = useCookie("authToken", {
+            sameSite: "none",
+            // cross-site requests
+            secure: true,
+            // must be https
+            path: "/",
+            expires: /* @__PURE__ */ new Date("2099-12-31")
+          });
+          authTokenCookie.value = response.data.access_token;
+          this.user = response.data.user;
+        }
+        return response;
+      } catch (error) {
+        return error.data;
+      }
+    },
+    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
+        });
+        if (response.status === "Success") {
+          return { status: response.status, message: response.message || "Password Update Successfully" };
+        } else {
+          const errorMessage = response.message;
+          throw new Error(errorMessage);
+        }
+      } catch (error) {
+        return error.data;
+      }
+    },
+    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;
+      } finally {
+      }
+    },
+    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;
+      }
+    },
+    // Password Reset APIs
+    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() {
@@ -45,7 +423,6 @@ export const useAuthStore = defineStore("auth", {
         localStorage.removeItem("auth_user");
       }
     },
-    // Mark as hydrated without loading
     setHydrated() {
       this._hydrated = true;
     }
@@ -55,5 +432,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/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/wishlists.d.ts

@@ -1,28 +1,136 @@
 export interface Wishlist {
     id: number;
-    name?: string;
+    title: string;
+    default: boolean;
+    created_at: string;
 }
 export interface WishlistProduct {
     id: number;
-    productSlug: string;
+    slug: string;
+    name: string;
+    image: string;
+    price: string;
+    pricefloat: number;
+    rp: string;
+    rpfloat: number;
+    type: string;
+    brandimage: string;
 }
 export interface WishlistProducts {
     [listId: number]: WishlistProduct[];
 }
+export interface CreateWishlistData {
+    title: string;
+    default: boolean;
+}
+export interface UpdateWishlistData {
+    title: string;
+    default: boolean;
+}
+export interface AddToWishlistData {
+}
+export interface ApiResponse<T> {
+    status: string;
+    message: string | Record<string, string[]> | null;
+    data: T | null;
+}
 export declare const useWishlistsStore: import("pinia").StoreDefinition<"wishlists", {
     wishlists: Wishlist[];
     wishlistProducts: WishlistProducts;
     loading: boolean;
     error: string | null;
-}, {}, {
+}, {
+    getWishlists: (state: {
+        wishlists: {
+            id: number;
+            title: string;
+            default: boolean;
+            created_at: string;
+        }[];
+        wishlistProducts: WishlistProducts;
+        loading: boolean;
+        error: string | null;
+    } & import("pinia").PiniaCustomStateProperties<{
+        wishlists: Wishlist[];
+        wishlistProducts: WishlistProducts;
+        loading: boolean;
+        error: string | null;
+    }>) => {
+        id: number;
+        title: string;
+        default: boolean;
+        created_at: string;
+    }[];
+    getWishlistProducts: (state: {
+        wishlists: {
+            id: number;
+            title: string;
+            default: boolean;
+            created_at: string;
+        }[];
+        wishlistProducts: WishlistProducts;
+        loading: boolean;
+        error: string | null;
+    } & import("pinia").PiniaCustomStateProperties<{
+        wishlists: Wishlist[];
+        wishlistProducts: WishlistProducts;
+        loading: boolean;
+        error: string | null;
+    }>) => (listId: number) => WishlistProduct[];
+    isLoading: (state: {
+        wishlists: {
+            id: number;
+            title: string;
+            default: boolean;
+            created_at: string;
+        }[];
+        wishlistProducts: WishlistProducts;
+        loading: boolean;
+        error: string | null;
+    } & import("pinia").PiniaCustomStateProperties<{
+        wishlists: Wishlist[];
+        wishlistProducts: WishlistProducts;
+        loading: boolean;
+        error: string | null;
+    }>) => boolean;
+    getError: (state: {
+        wishlists: {
+            id: number;
+            title: string;
+            default: boolean;
+            created_at: string;
+        }[];
+        wishlistProducts: WishlistProducts;
+        loading: boolean;
+        error: string | null;
+    } & import("pinia").PiniaCustomStateProperties<{
+        wishlists: Wishlist[];
+        wishlistProducts: WishlistProducts;
+        loading: boolean;
+        error: string | null;
+    }>) => string | null;
+}, {
+    setLoading(loading: boolean): void;
+    setError(error: string | null): void;
     setWishlists(wishlists: Wishlist[]): void;
     addWishlist(wishlist: Wishlist): void;
     updateWishlist(updatedWishlist: Wishlist): void;
-    removeWishlist(id: number): void;
+    updateWishlist(id: number, data: UpdateWishlistData): Promise<ApiResponse<Wishlist>>;
+    removeWishlist(wishlistId: number): void;
     setWishlistProducts(listId: number, products: WishlistProduct[]): void;
     addWishlistProduct(listId: number, product: WishlistProduct): void;
     removeWishlistProduct(listId: number, productSlug: string): void;
     clearWishlistProducts(listId: number): void;
-    setLoading(loading: boolean): void;
-    setError(error: string | null): void;
+    fetchWishlists(force?: boolean): Promise<ApiResponse<Wishlist[]>>;
+    fetchWishlistProducts(listId: number): Promise<ApiResponse<{
+        id: number;
+        title: string;
+        default: boolean;
+        created_at: string;
+        products: WishlistProduct[];
+    }>>;
+    createWishlist(data: CreateWishlistData): Promise<ApiResponse<Wishlist>>;
+    addToWishlist(listId: number, productSlug: string, data?: AddToWishlistData): Promise<ApiResponse<WishlistProduct>>;
+    removeFromWishlist(listId: number, productSlug: string): Promise<ApiResponse<void>>;
+    deleteWishlist(id: number): Promise<ApiResponse<void>>;
 }>;