flowrix 1.0.1-beta.8 → 1.0.1-beta.81

package/dist/runtime/stores/wishlists.js

@@ -1,4 +1,6 @@
 import { defineStore } from "pinia";
+import { flowrixApi } from "../middleware/flowrix.js";
+import { useRuntimeConfig } from "#imports";
 export const useWishlistsStore = defineStore("wishlists", {
   state: () => ({
     wishlists: [],
@@ -7,11 +9,17 @@ export const useWishlistsStore = defineStore("wishlists", {
     error: null
   }),
   actions: {
+    setLoading(loading) {
+      this.loading = loading;
+    },
+    setError(error) {
+      this.error = error;
+    },
     setWishlists(wishlists) {
       this.wishlists = wishlists;
     },
     addWishlist(wishlist) {
-      this.wishlists.unshift(wishlist);
+      this.wishlists.push(wishlist);
     },
     updateWishlist(updatedWishlist) {
       const index = this.wishlists.findIndex((w) => w.id === updatedWishlist.id);
@@ -19,8 +27,8 @@ export const useWishlistsStore = defineStore("wishlists", {
         this.wishlists[index] = updatedWishlist;
       }
     },
-    removeWishlist(id) {
-      this.wishlists = this.wishlists.filter((w) => w.id !== id);
+    removeWishlist(wishlistId) {
+      this.wishlists = this.wishlists.filter((w) => w.id !== wishlistId);
     },
     setWishlistProducts(listId, products) {
       this.wishlistProducts[listId] = products;
@@ -29,21 +37,213 @@ export const useWishlistsStore = defineStore("wishlists", {
       if (!this.wishlistProducts[listId]) {
         this.wishlistProducts[listId] = [];
       }
-      this.wishlistProducts[listId].unshift(product);
+      this.wishlistProducts[listId].push(product);
     },
     removeWishlistProduct(listId, productSlug) {
       if (this.wishlistProducts[listId]) {
-        this.wishlistProducts[listId] = this.wishlistProducts[listId].filter((p) => p.productSlug !== productSlug);
+        this.wishlistProducts[listId] = this.wishlistProducts[listId].filter(
+          (product) => product.slug !== productSlug
+          // Changed from productSlug to slug
+        );
       }
     },
     clearWishlistProducts(listId) {
       delete this.wishlistProducts[listId];
     },
-    setLoading(loading) {
-      this.loading = loading;
+    // Fetch all wishlists - Added force param for cache bypass
+    async fetchWishlists(force = false) {
+      if (!force && this.wishlists.length > 0) {
+        return {
+          status: "Success",
+          data: this.wishlists,
+          message: null
+        };
+      }
+      try {
+        const config = useRuntimeConfig();
+        let rawCookies = "";
+        if (process.client) {
+          rawCookies = document.cookie || "";
+        }
+        const apiConfig = {
+          ...config,
+          cookies: rawCookies
+        };
+        const apiUrl = "mystore/customer/wishlist";
+        const response = await flowrixApi.get(apiUrl, apiConfig, {});
+        if (response.status === "Success") {
+          this.wishlists = response.data || [];
+          return response;
+        } else {
+          return response;
+        }
+      } catch (error) {
+        return error.data;
+      }
     },
-    setError(error) {
-      this.error = error;
+    // Fetch products for a specific wishlist
+    async fetchWishlistProducts(listId) {
+      try {
+        const config = useRuntimeConfig();
+        let rawCookies = "";
+        if (process.client) {
+          rawCookies = document.cookie || "";
+        }
+        const apiConfig = {
+          ...config,
+          cookies: rawCookies
+        };
+        const apiUrl = `mystore/customer/wishlist/${listId}/products`;
+        const response = await flowrixApi.get(apiUrl, apiConfig, {});
+        if (response.status === "Success" && response.data) {
+          const products = response.data.products || [];
+          this.setWishlistProducts(listId, products);
+          return response;
+        } else {
+          return response;
+        }
+      } catch (error) {
+        return error.data;
+      }
+    },
+    // Create a new wishlist
+    async createWishlist(data) {
+      try {
+        const config = useRuntimeConfig();
+        let rawCookies = "";
+        if (process.client) {
+          rawCookies = document.cookie || "";
+        }
+        const apiConfig = {
+          ...config,
+          cookies: rawCookies
+        };
+        const apiUrl = "mystore/customer/wishlist/add";
+        const response = await flowrixApi.post(apiUrl, apiConfig, {
+          body: data
+        });
+        if (response.status === "Success") {
+          await this.fetchWishlists(true);
+          return response;
+        } else {
+          return response;
+        }
+      } catch (error) {
+        return error.data;
+      }
+    },
+    // Add product to wishlist
+    async addToWishlist(listId, productSlug, data = {}) {
+      try {
+        const config = useRuntimeConfig();
+        let rawCookies = "";
+        if (process.client) {
+          rawCookies = document.cookie || "";
+        }
+        const apiConfig = {
+          ...config,
+          cookies: rawCookies
+        };
+        const apiUrl = `mystore/customer/wishlist/${listId}/${productSlug}/add`;
+        const response = await flowrixApi.post(apiUrl, apiConfig, {
+          body: data
+        });
+        if (response.status === "Success" && response.data) {
+          this.addWishlistProduct(listId, response.data);
+          return response;
+        } else {
+          return response;
+        }
+      } catch (error) {
+        return error.data;
+      }
+    },
+    // Remove product from wishlist
+    async removeFromWishlist(listId, productSlug) {
+      try {
+        const config = useRuntimeConfig();
+        let rawCookies = "";
+        if (process.client) {
+          rawCookies = document.cookie || "";
+        }
+        const apiConfig = {
+          ...config,
+          cookies: rawCookies
+        };
+        const apiUrl = `mystore/customer/wishlist/${listId}/item/delete`;
+        const response = await flowrixApi.post(apiUrl, apiConfig, {
+          body: { ids: { productSlug } }
+          // Assuming API expects this format
+        });
+        if (response.status === "Success") {
+          this.removeWishlistProduct(listId, productSlug);
+          await this.fetchWishlistProducts(listId);
+          return response;
+        } else {
+          return response;
+        }
+      } catch (error) {
+        return error.data;
+      }
+    },
+    // Update wishlist
+    async updateWishlist(id, data) {
+      try {
+        const config = useRuntimeConfig();
+        let rawCookies = "";
+        if (process.client) {
+          rawCookies = document.cookie || "";
+        }
+        const apiConfig = {
+          ...config,
+          cookies: rawCookies
+        };
+        const apiUrl = `mystore/customer/wishlist/${id}/update`;
+        const response = await flowrixApi.post(apiUrl, apiConfig, {
+          body: data
+        });
+        if (response.status === "Success" && response.data) {
+          this.updateWishlist(response.data);
+          return response;
+        } else {
+          return response;
+        }
+      } catch (error) {
+        return error.data;
+      }
+    },
+    // Delete wishlist
+    async deleteWishlist(id) {
+      try {
+        const config = useRuntimeConfig();
+        let rawCookies = "";
+        if (process.client) {
+          rawCookies = document.cookie || "";
+        }
+        const apiConfig = {
+          ...config,
+          cookies: rawCookies
+        };
+        const apiUrl = `mystore/customer/wishlist/${id}/delete`;
+        const response = await flowrixApi.post(apiUrl, apiConfig, {
+          body: {}
+        });
+        if (response.status === "Success") {
+          this.removeWishlist(id);
+          this.clearWishlistProducts(id);
+          return response;
+        } else {
+          return response;
+        }
+      } catch (error) {
+        return error.data;
+      }
     }
+  },
+  getters: {
+    getWishlists: (state) => state.wishlists,
+    getWishlistProducts: (state) => (listId) => state.wishlistProducts[listId] || [],
+    isLoading: (state) => state.loading,
+    getError: (state) => state.error
   }
 });

package/dist/runtime/utils/api.js

@@ -1,3 +1,5 @@
+import { useRuntimeConfig } from "nuxt/app";
+import { useCookie } from "nuxt/app";
 import { useAuthStore } from "../stores/auth.js";
 function getLocationHeaders() {
   const headers = {};
@@ -32,26 +34,20 @@ function getLocationHeaders() {
   }
   return headers;
 }
-function getEnv(key) {
-  if (typeof useRuntimeConfig === "function") {
-    const config = useRuntimeConfig();
-    return config.public?.[key] || config[key];
-  }
-  return process.env[key];
-}
 export function useApi() {
   const authStore = useAuthStore();
-  const FLOWRIX_API_KEY = getEnv("FLOWRIX_API_KEY");
-  const FLOWRIX_API_SECRET = getEnv("FLOWRIX_API_SECRET");
-  const FLOWRIX_API_ORIGIN = getEnv("FLOWRIX_API_ORIGIN");
-  const FLOWRIX_API_BASE = getEnv("FLOWRIX_API_BASE");
+  const config = useRuntimeConfig();
+  const FLOWRIX_API_KEY = config.public.FLOWRIX_API_KEY;
+  const FLOWRIX_API_SECRET = config.public.FLOWRIX_API_SECRET;
+  const FLOWRIX_API_ORIGIN = config.public.FLOWRIX_API_ORIGIN;
+  const FLOWRIX_API_BASE = config.public.FLOWRIX_API_BASE;
   const baseURL = FLOWRIX_API_BASE || "";
   async function request(method, url, data = null, options = {}, extraHeaders = {}) {
     const locationHeaders = getLocationHeaders();
     const headers = {
       "Content-Type": "application/json",
-      "X-API-Key": FLOWRIX_API_KEY,
-      "X-API-Secret": FLOWRIX_API_SECRET,
+      "x-public-key": FLOWRIX_API_KEY,
+      "x-api-secret": FLOWRIX_API_SECRET,
       // Add location headers from cookies
       ...locationHeaders,
       // Add extra headers

package/dist/runtime/utils/htmlCache.d.ts

@@ -0,0 +1,5 @@
+export declare function readCache(url: URL, customerType: number): Promise<string | null>;
+export declare function writeCache(url: URL, html: string, customerType: number): Promise<void>;
+export declare function clearCache(): Promise<void>;
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<string | undefined>>;
+export default _default;

package/dist/runtime/utils/htmlCache.js

@@ -0,0 +1,60 @@
+import { promises as fs } from "fs";
+import { join } from "path";
+import { getRequestURL, defineEventHandler, getCookie } from "h3";
+const cacheDir = join("/tmp", ".cache", "html");
+async function ensureDir() {
+  await fs.mkdir(cacheDir, { recursive: true });
+}
+function getCacheFilePath(url, customerType) {
+  const { pathname, searchParams } = url;
+  const queryObj = {};
+  for (const [key, value] of searchParams.entries()) {
+    queryObj[key] = value;
+  }
+  const queryString = Object.keys(queryObj).length ? `_${JSON.stringify(queryObj)}` : "";
+  const cacheKey = `${pathname}${queryString}`;
+  const safeName = cacheKey.replace(/[^a-zA-Z0-9-_]/g, "_") || "index";
+  return join(cacheDir, `${safeName}-__-${customerType}.html`);
+}
+export async function readCache(url, customerType) {
+  try {
+    const filePath = getCacheFilePath(url, customerType);
+    const html = await fs.readFile(filePath, "utf8");
+    return html;
+  } catch {
+    return null;
+  }
+}
+export async function writeCache(url, html, customerType) {
+  await ensureDir();
+  const filePath = getCacheFilePath(url, customerType);
+  await fs.writeFile(filePath, html, "utf8");
+}
+export async function clearCache() {
+  try {
+    await fs.rm(cacheDir, { recursive: true, force: true });
+    await ensureDir();
+  } catch {
+  }
+}
+export default defineEventHandler(async (event) => {
+  const url = getRequestURL(event);
+  const customerType = getCookie(event, "customertype") || "";
+  if (event.method !== "GET" || !event.headers.get("accept")?.includes("text/html")) return;
+  const cached = await readCache(url, customerType);
+  if (cached) {
+    event.node.res.setHeader("x-cache", "HIT");
+    return cached;
+  }
+  const originalEnd = event.node.res.end;
+  let chunks = [];
+  event.node.res.end = function(chunk) {
+    if (chunk) chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    const html = Buffer.concat(chunks).toString("utf-8");
+    if (event.node.res.statusCode === 200 && html.includes("<!DOCTYPE html>")) {
+      writeCache(url, html, customerType);
+    }
+    return originalEnd.apply(this, arguments);
+  };
+  return;
+});

package/dist/types.d.mts

@@ -1,3 +1,7 @@
-export { default } from './module.mjs'
+import type { NuxtModule } from '@nuxt/schema'
+
+import type { default as Module } from './module.mjs'
 
-export { type ModuleOptions } from './module.mjs'
+export type ModuleOptions = typeof Module extends NuxtModule<infer O> ? Partial<O> : Record<string, any>
+
+export { default } from './module.mjs'

package/package.json

@@ -1,13 +1,17 @@
 {
   "name": "flowrix",
-  "version": "1.0.1-beta.8",
-  "description": "lug-and-play Nuxt eCommerce cart powered by FLOWRiX. Subscription required.",
+  "version": "1.0.1-beta.81",
+  "description": "Plug-and-play Nuxt eCommerce cart powered by FLOWRiX. Subscription required.",
   "license": "MIT",
   "type": "module",
   "exports": {
     ".": {
       "types": "./dist/types.d.mts",
       "import": "./dist/module.mjs"
+    },
+    "./composables": {
+      "types": "./dist/runtime/composables/index.d.ts",
+      "import": "./dist/runtime/composables/index.js"
     }
   },
   "main": "./dist/module.mjs",
@@ -15,12 +19,14 @@
     "*": {
       ".": [
         "./dist/types.d.mts"
+      ],
+      "composables": [
+        "./dist/runtime/composables/index.d.ts"
       ]
     }
   },
   "files": [
-    "dist",
-    "runtime/stores"
+    "dist"
   ],
   "scripts": {
     "prepack": "nuxt-module-build build",
@@ -34,24 +40,30 @@
     "test:types": "vue-tsc --noEmit && cd playground && vue-tsc --noEmit"
   },
   "dependencies": {
-    "@nuxt/kit": "^4.1.3",
-    "@pinia/nuxt": "^0.7.0",
-    "@stripe/stripe-js": "^8.2.0",
-    "pinia": "^2.1.7",
-    "pinia-plugin-persistedstate": "^3.2.0"
+    "@nuxt/image": "^1.11.0",
+    "@nuxt/kit": "4.2.0",
+    "@nuxtjs/seo": "^3.2.2",
+    "@pinia/nuxt": "0.7.0",
+    "@stripe/stripe-js": "8.2.0",
+    "@vueuse/nuxt": "^14.0.0",
+    "nuxt-gtag": "^4.1.0",
+    "nuxt-swiper": "^2.0.1",
+    "nuxt-toast": "^1.4.0",
+    "pinia": "2.3.1",
+    "pinia-plugin-persistedstate": "^3.2.3"
   },
   "devDependencies": {
-    "@nuxt/devtools": "^2.6.5",
-    "@nuxt/eslint-config": "^1.9.0",
+    "@nuxt/devtools": "2.6.5",
+    "@nuxt/eslint-config": "1.9.0",
     "@nuxt/module-builder": "^1.0.2",
-    "@nuxt/schema": "^4.1.3",
-    "@nuxt/test-utils": "^3.19.2",
-    "@types/node": "latest",
-    "changelogen": "^0.6.2",
-    "eslint": "^9.38.0",
-    "nuxt": "^4.1.3",
-    "typescript": "~5.9.3",
-    "vitest": "^3.2.4",
-    "vue-tsc": "^3.1.1"
+    "@nuxt/schema": "4.2.0",
+    "@nuxt/test-utils": "3.19.2",
+    "@types/node": "24.9.1",
+    "changelogen": "0.6.2",
+    "eslint": "9.38.0",
+    "nuxt": "4.2.0",
+    "typescript": "5.9.3",
+    "vitest": "3.2.4",
+    "vue-tsc": "3.1.1"
   }
 }

package/dist/runtime/composables/useAuth.d.ts

@@ -1,45 +0,0 @@
-import { type User } from '../stores/auth.js';
-export interface AuthCredentials {
-    email: string;
-    password: string;
-}
-export interface ChangePasswordData {
-    current_password: string;
-    password: string;
-    password_confirmation: string;
-}
-export interface AuthResponse {
-    status: string;
-    message: string | Record<string, string[]> | null;
-    data: {
-        access_token: string;
-        token_type: string;
-        expires_in: number | null;
-        user: User;
-    } | null;
-}
-export declare function useAuth(): {
-    login: (credentials: AuthCredentials) => Promise<AuthResponse>;
-    register: (data: AuthCredentials & {
-        name?: string;
-    }) => Promise<AuthResponse>;
-    verifyEmail: (email: string) => Promise<AuthResponse>;
-    verifyToken: (email: string, token: string) => Promise<AuthResponse>;
-    resetPassword: (token: string, password: string, password_confirmation: string) => Promise<AuthResponse>;
-    logout: () => Promise<void>;
-    fetchProfile: () => Promise<User | null>;
-    updateProfile: (userData: any) => Promise<{
-        status: string;
-        message: string;
-    }>;
-    changePassword: (passwordData: ChangePasswordData) => Promise<{
-        status: string;
-        message: string;
-    }>;
-    initializeAuth: () => void;
-    formatErrorMessage: (message: string | Record<string, string[]> | null) => string;
-    user: import("vue").ComputedRef<User | null>;
-    token: import("vue").ComputedRef<string | null>;
-    isAuthenticated: import("vue").ComputedRef<boolean>;
-    isHydrated: import("vue").ComputedRef<boolean>;
-};

package/dist/runtime/composables/useAuth.js

@@ -1,180 +0,0 @@
-import { computed } from "vue";
-import { useAuthStore } from "../stores/auth.js";
-import { useApi } from "../utils/api.js";
-export function useAuth() {
-  const authStore = useAuthStore();
-  const { post, get } = useApi();
-  function formatErrorMessage(message) {
-    if (!message) return "";
-    if (typeof message === "string") {
-      return message;
-    }
-    const errorMessages = [];
-    for (const [, errors] of Object.entries(message)) {
-      if (Array.isArray(errors)) {
-        errorMessages.push(...errors);
-      } else {
-        errorMessages.push(String(errors));
-      }
-    }
-    return errorMessages.join(", ");
-  }
-  async function login(credentials) {
-    try {
-      const response = await post("/login", credentials);
-      if (response.status === "Success" && response.data?.access_token && response.data?.user) {
-        authStore.setAuth({
-          user: response.data.user,
-          token: response.data.access_token
-        });
-      }
-      return response;
-    } catch (error) {
-      console.error("Login error:", error);
-      const message = error.data ? formatErrorMessage(error.data.message) : error.message || "Login failed";
-      return {
-        status: "Error",
-        message,
-        data: null
-      };
-    }
-  }
-  async function register(data) {
-    try {
-      const response = await post("/customer/create", data);
-      return response;
-    } catch (error) {
-      console.error("Registration error:", error);
-      const message = error.data ? formatErrorMessage(error.data.message) : error.message || "Registration failed";
-      return {
-        status: "Error",
-        message,
-        data: null
-      };
-    }
-  }
-  async function verifyEmail(email) {
-    try {
-      const response = await post("/verify-email", { 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 function verifyToken(email, token) {
-    try {
-      const response = await post("/verify-token", { 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 function resetPassword(token, password, password_confirmation) {
-    try {
-      const response = await post("/reset-password", {
-        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
-      };
-    }
-  }
-  async function logout() {
-    try {
-      await post("/customer/logout", {});
-    } catch (error) {
-      console.error("Logout API failed:", error);
-    } finally {
-      authStore.logout();
-    }
-  }
-  async function fetchProfile() {
-    try {
-      const response = await get("/customer/profile");
-      if (response.status === "Success" && response.data) {
-        authStore.user = response.data;
-        if (import.meta.client) {
-          localStorage.setItem("auth_user", JSON.stringify(response.data));
-        }
-        return response.data;
-      }
-      return null;
-    } catch (error) {
-      console.error("Fetch profile failed:", error);
-      return null;
-    }
-  }
-  async function updateProfile(userData) {
-    try {
-      const response = await post("/customer/profile/update", userData);
-      if (response.status === "Success") {
-        await fetchProfile();
-        return { status: response.status, message: response.message || "Profile Updated Successfully" };
-      } else {
-        const errorMessage = formatErrorMessage(response.message);
-        throw new Error(errorMessage);
-      }
-    } catch (error) {
-      console.error("Update profile error:", error);
-      const errorMessage = error.data ? formatErrorMessage(error.data.message) : error.message || "Failed to update profile";
-      throw new Error(errorMessage);
-    }
-  }
-  async function changePassword(passwordData) {
-    try {
-      const response = await post("/customer/change-password", passwordData);
-      if (response.status === "Success") {
-        return { status: "Success", message: "Password updated successfully" };
-      } else {
-        const errorMessage = formatErrorMessage(response.message);
-        throw new Error(errorMessage);
-      }
-    } catch (error) {
-      console.error("Change password error:", error);
-      const errorMessage = error.data ? formatErrorMessage(error.data.message) : error.message || "Failed to change password";
-      throw new Error(errorMessage);
-    }
-  }
-  const initializeAuth = () => {
-    if (import.meta.client && !authStore.isHydrated) {
-      authStore.loadAuth();
-    }
-  };
-  return {
-    login,
-    register,
-    verifyEmail,
-    verifyToken,
-    resetPassword,
-    logout,
-    fetchProfile,
-    updateProfile,
-    changePassword,
-    initializeAuth,
-    formatErrorMessage,
-    user: computed(() => authStore.getUser),
-    token: computed(() => authStore.getToken),
-    isAuthenticated: computed(() => authStore.isLoggedIn),
-    isHydrated: computed(() => authStore.isHydrated)
-  };
-}