flowrix 1.0.1-beta.85 → 1.0.1-beta.86

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

@@ -0,0 +1,136 @@
+export interface Wishlist {
+    id: number;
+    title: string;
+    default: boolean;
+    created_at: string;
+}
+export interface WishlistProduct {
+    id: number;
+    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;
+    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;
+    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>>;
+}>;

package/dist/runtime/stores/wishlists.js

@@ -0,0 +1,249 @@
+import { defineStore } from "pinia";
+import { flowrixApi } from "../middleware/flowrix.js";
+import { useRuntimeConfig } from "#imports";
+export const useWishlistsStore = defineStore("wishlists", {
+  state: () => ({
+    wishlists: [],
+    wishlistProducts: {},
+    loading: false,
+    error: null
+  }),
+  actions: {
+    setLoading(loading) {
+      this.loading = loading;
+    },
+    setError(error) {
+      this.error = error;
+    },
+    setWishlists(wishlists) {
+      this.wishlists = wishlists;
+    },
+    addWishlist(wishlist) {
+      this.wishlists.push(wishlist);
+    },
+    updateWishlist(updatedWishlist) {
+      const index = this.wishlists.findIndex((w) => w.id === updatedWishlist.id);
+      if (index !== -1) {
+        this.wishlists[index] = updatedWishlist;
+      }
+    },
+    removeWishlist(wishlistId) {
+      this.wishlists = this.wishlists.filter((w) => w.id !== wishlistId);
+    },
+    setWishlistProducts(listId, products) {
+      this.wishlistProducts[listId] = products;
+    },
+    addWishlistProduct(listId, product) {
+      if (!this.wishlistProducts[listId]) {
+        this.wishlistProducts[listId] = [];
+      }
+      this.wishlistProducts[listId].push(product);
+    },
+    removeWishlistProduct(listId, productSlug) {
+      if (this.wishlistProducts[listId]) {
+        this.wishlistProducts[listId] = this.wishlistProducts[listId].filter(
+          (product) => product.slug !== productSlug
+          // Changed from productSlug to slug
+        );
+      }
+    },
+    clearWishlistProducts(listId) {
+      delete this.wishlistProducts[listId];
+    },
+    // 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;
+      }
+    },
+    // 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.d.ts

@@ -0,0 +1,13 @@
+import type { FetchOptions } from "ofetch";
+export interface ApiErrorResponse {
+    status: string;
+    message: string | Record<string, string[]>;
+    data: any;
+}
+export declare function useApi(): {
+    get: <T>(url: string, options?: FetchOptions, extraHeaders?: Record<string, string>) => Promise<T>;
+    post: <T>(url: string, data: any, options?: FetchOptions, extraHeaders?: Record<string, string>) => Promise<T>;
+    patch: <T>(url: string, data: any, options?: FetchOptions, extraHeaders?: Record<string, string>) => Promise<T>;
+    put: <T>(url: string, data: any, options?: FetchOptions, extraHeaders?: Record<string, string>) => Promise<T>;
+    delete: <T>(url: string, options?: FetchOptions, extraHeaders?: Record<string, string>) => Promise<T>;
+};

package/dist/runtime/utils/api.js

@@ -0,0 +1,98 @@
+import { useRuntimeConfig } from "nuxt/app";
+import { useCookie } from "nuxt/app";
+import { useAuthStore } from "../stores/auth.js";
+function getLocationHeaders() {
+  const headers = {};
+  if (process.client) {
+    try {
+      const locationCookie = useCookie("location");
+      if (locationCookie.value && typeof locationCookie.value === "object") {
+        const location = locationCookie.value;
+        if (location.country) {
+          headers["shipping-country"] = location.country_id;
+        }
+      }
+      const ipLocationCookie = useCookie("IpLocation");
+      if (ipLocationCookie.value && typeof ipLocationCookie.value === "object") {
+        const ipLocation = ipLocationCookie.value;
+        const locationData = ipLocation.location;
+        if (locationData) {
+          if (locationData.country_id && !headers["shipping-country"]) {
+            headers["shipping-country"] = locationData.country_id;
+          }
+          if (locationData.region_id) {
+            headers["shipping-region"] = locationData.region_id;
+          }
+          if (locationData.zip_code) {
+            headers["shipping-postcode"] = locationData.zip_code;
+          }
+        }
+      }
+    } catch (error) {
+      console.warn("Failed to read location cookies on client:", error);
+    }
+  }
+  return headers;
+}
+export function useApi() {
+  const authStore = useAuthStore();
+  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-public-key": FLOWRIX_API_KEY,
+      "x-api-secret": FLOWRIX_API_SECRET,
+      // Add location headers from cookies
+      ...locationHeaders,
+      // Add extra headers
+      ...extraHeaders,
+      // Add auth header if available (should be last to override if needed)
+      ...authStore.getToken ? { Authorization: `Bearer ${authStore.getToken}` } : {}
+    };
+    try {
+      const requestOptions = {
+        method,
+        baseURL,
+        headers,
+        body: data ? JSON.stringify(data) : void 0,
+        ...options
+      };
+      const response = await $fetch(url, requestOptions);
+      return response;
+    } catch (error) {
+      console.error("API Error:", error);
+      if (error.response?._data || error.data) {
+        const apiError = error.response?._data || error.data;
+        let errorMessage = "An error occurred";
+        if (apiError.message) {
+          if (typeof apiError.message === "string") {
+            errorMessage = apiError.message;
+          } else if (typeof apiError.message === "object" && apiError.message !== null) {
+            const errors = Object.values(apiError.message).flat();
+            errorMessage = errors.join(", ");
+          }
+        } else if (apiError.status === "Error") {
+          errorMessage = "Validation failed. Please check your input.";
+        }
+        throw new Error(errorMessage);
+      }
+      if (error.statusCode === 422) {
+        throw new Error("Validation failed. Please check your input.");
+      }
+      throw new Error(error.message || "API request failed");
+    }
+  }
+  return {
+    get: (url, options = {}, extraHeaders = {}) => request("GET", url, null, options, extraHeaders),
+    post: (url, data, options = {}, extraHeaders = {}) => request("POST", url, data, options, extraHeaders),
+    patch: (url, data, options = {}, extraHeaders = {}) => request("PATCH", url, data, options, extraHeaders),
+    put: (url, data, options = {}, extraHeaders = {}) => request("PUT", url, data, options, extraHeaders),
+    delete: (url, options = {}, extraHeaders = {}) => request("DELETE", url, null, options, extraHeaders)
+  };
+}

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

@@ -0,0 +1,22 @@
+export interface CompanyProfile {
+    limit: number;
+    logo: string;
+    name: string;
+    phone: string;
+    mobile: string;
+    country: string;
+    country_id: number;
+    state: string;
+    state_id: number;
+    suburb: string;
+    postcode: string;
+    disclaimer: string;
+    abn: string;
+    recaptcha: string;
+    robots: string;
+    currencyCode: string;
+    currencySymbol: string;
+    currencyprefix: string;
+    currencypostfix: string;
+}
+export declare const defaultCompanyProfile: CompanyProfile;

package/dist/runtime/utils/companyProfile.js

@@ -0,0 +1,21 @@
+export const defaultCompanyProfile = {
+  limit: 50,
+  logo: "",
+  name: "",
+  phone: "",
+  mobile: "",
+  country: "",
+  country_id: 0,
+  state: "",
+  state_id: 0,
+  suburb: "",
+  postcode: "",
+  disclaimer: "",
+  abn: "",
+  recaptcha: "",
+  robots: "",
+  currencyCode: "",
+  currencySymbol: "",
+  currencyprefix: "",
+  currencypostfix: ""
+};

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,64 @@
+import { promises as fs } from "fs";
+import { join } from "path";
+import { getRequestURL, defineEventHandler, getCookie } from "h3";
+import { useRuntimeConfig } from "#imports";
+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 config = useRuntimeConfig();
+  const customerType = getCookie(event, "customertype") || 1;
+  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>")) {
+      if (config.public.FLOWRIX_CACHE == true) {
+        writeCache(url, html, customerType);
+      }
+    }
+    return originalEnd.apply(this, arguments);
+  };
+  return;
+});

package/dist/types.d.mts

@@ -0,0 +1,7 @@
+import type { NuxtModule } from '@nuxt/schema'
+
+import type { default as Module } 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,6 +1,6 @@
 {
   "name": "flowrix",
-  "version": "1.0.1-beta.85",
+  "version": "1.0.1-beta.86",
   "description": "Plug-and-play Nuxt eCommerce cart powered by FLOWRiX. Subscription required.",
   "license": "MIT",
   "type": "module",
@@ -28,6 +28,17 @@
   "files": [
     "dist"
   ],
+  "scripts": {
+    "prepack": "nuxt-module-build build",
+    "dev": "npm run dev:prepare && nuxi dev playground",
+    "dev:build": "nuxi build playground",
+    "dev:prepare": "nuxt-module-build build --stub && nuxt-module-build prepare && nuxi prepare playground",
+    "release": "npm run lint && npm run test && npm run prepack && changelogen --release && npm publish && git push --follow-tags",
+    "lint": "eslint .",
+    "test": "vitest run",
+    "test:watch": "vitest watch",
+    "test:types": "vue-tsc --noEmit && cd playground && vue-tsc --noEmit"
+  },
   "dependencies": {
     "@nuxt/image": "1.11.0",
     "@nuxt/kit": "4.2.0",

package/dist/module.d.cts

@@ -1,2 +0,0 @@
-export * from "D:/nuxtdevelopment/build_crosby_with_node_module/flowrix-nodemodule/src/module.js";
-export { default } from "D:/nuxtdevelopment/build_crosby_with_node_module/flowrix-nodemodule/src/module.js";