flowrix 1.0.0

package/dist/runtime/server/api/product/[...slug].js

@@ -0,0 +1,44 @@
+import { defineEventHandler, getQuery, createError, readBody } from "h3";
+import { writeFile, mkdir, readFile } from "fs/promises";
+import { join } from "path";
+import { flowrixApi } from "../../../middleware/flowrix.js";
+const CACHE_DIR = join(process.cwd(), ".nuxt", "cache", "nitro", "products");
+export const productCache = /* @__PURE__ */ new Map();
+async function ensureCacheDir() {
+  try {
+    await mkdir(CACHE_DIR, { recursive: true });
+  } catch (error) {
+    console.error("Error creating cache directory:", error);
+  }
+}
+export default defineEventHandler(async (event) => {
+  const slug = event.context.params._;
+  const query = getQuery(event);
+  const body = await readBody(event);
+  if (!slug) {
+    throw createError({ statusCode: 400, statusMessage: "Missing slug parameter" });
+  }
+  const cacheKey = `${slug}-${JSON.stringify(query)}`;
+  const fileName = cacheKey.replace(/[^a-zA-Z0-9-_]/g, "_");
+  const filePath = join(CACHE_DIR, `${fileName}.json`);
+  try {
+    const fileContent = await readFile(filePath, "utf-8");
+    const product = JSON.parse(fileContent);
+    return product;
+  } catch (error) {
+  }
+  try {
+    const product = await flowrixApi.post(`product/${slug}`, {
+      body: JSON.stringify(body)
+    }, "v2");
+    await ensureCacheDir();
+    await writeFile(filePath, JSON.stringify(product, null, 2), "utf-8");
+    return product;
+  } catch (error) {
+    throw createError({
+      statusCode: 500,
+      statusMessage: `Failed to fetch product for slug: ${slug}`,
+      data: error.message
+    });
+  }
+});

package/dist/runtime/server/api/service/[slug].d.ts

@@ -0,0 +1,3 @@
+export declare const serviceCache: Map<any, any>;
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<any>>;
+export default _default;

package/dist/runtime/server/api/service/[slug].js

@@ -0,0 +1,51 @@
+import { defineEventHandler, getRouterParam, getQuery, createError, readBody } from "h3";
+import { $fetch } from "ofetch";
+import { writeFile, mkdir, readFile } from "fs/promises";
+import { join } from "path";
+const CACHE_DIR = join(process.cwd(), ".nuxt", "cache", "nitro", "services");
+export const serviceCache = /* @__PURE__ */ new Map();
+async function ensureCacheDir() {
+  try {
+    await mkdir(CACHE_DIR, { recursive: true });
+  } catch (error) {
+    console.error("Error creating cache directory:", error);
+  }
+}
+export default defineEventHandler(async (event) => {
+  const slug = getRouterParam(event, "slug");
+  const query = getQuery(event);
+  const body = await readBody(event);
+  if (!slug) {
+    throw createError({ statusCode: 400, statusMessage: "Missing slug parameter" });
+  }
+  if (!/^[a-zA-Z0-9-_]+$/.test(slug)) {
+    throw createError({ statusCode: 400, statusMessage: "Invalid slug" });
+  }
+  const cacheKey = `${slug}-${JSON.stringify(query)}`;
+  const fileName = cacheKey.replace(/[^a-zA-Z0-9-_]/g, "_");
+  const filePath = join(CACHE_DIR, `${fileName}.json`);
+  try {
+    const fileContent = await readFile(filePath, "utf-8");
+    const service = JSON.parse(fileContent);
+    return service;
+  } catch (error) {
+  }
+  try {
+    const service = await $fetch(`${process.env.FLOWRIX_API_BASE}services/${slug}`, {
+      headers: {
+        "x-api-key": process.env.FLOWRIX_API_KEY,
+        "x-api-secret": process.env.FLOWRIX_API_SECRET,
+        "Origin": process.env.FLOWRIX_API_ORIGIN
+      }
+    });
+    await ensureCacheDir();
+    await writeFile(filePath, JSON.stringify(service, null, 2), "utf-8");
+    return service;
+  } catch (error) {
+    throw createError({
+      statusCode: 500,
+      statusMessage: `Failed to fetch service for slug: ${slug}`,
+      data: error.message
+    });
+  }
+});

package/dist/runtime/server/api/service/availability.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<any>>;
+export default _default;

package/dist/runtime/server/api/service/availability.js

@@ -0,0 +1,27 @@
+import { defineEventHandler, readBody } from "h3";
+export default defineEventHandler(async (event) => {
+  const body = await readBody(event);
+  try {
+    const response = await fetch(`${process.env.FLOWRIX_API_BASE}services/availability`, {
+      method: "POST",
+      headers: {
+        "x-api-key": process.env.FLOWRIX_API_KEY || "",
+        "x-api-secret": process.env.FLOWRIX_API_SECRET || "",
+        "Origin": process.env.FLOWRIX_API_ORIGIN || "",
+        "Content-Type": "application/json",
+        "Accept": "application/json"
+      },
+      body: JSON.stringify(body)
+    });
+    const responseData = await response.json();
+    return responseData;
+  } catch (error) {
+    console.error("Error in service availability:", error);
+    return {
+      status: "Error",
+      statusCode: 500,
+      message: "Internal server error",
+      error: error.message || "Unknown error"
+    };
+  }
+});

package/dist/runtime/server/api/subscribe.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<any>>;
+export default _default;

package/dist/runtime/server/api/subscribe.js

@@ -0,0 +1,16 @@
+import { defineEventHandler, readBody } from "h3";
+import { $fetch } from "ofetch";
+export default defineEventHandler(async (event) => {
+  const body = await readBody(event);
+  const subscribe = await $fetch(`${process.env.FLOWRIX_API_BASE}subscribe`, {
+    method: "POST",
+    headers: {
+      "x-api-key": process.env.FLOWRIX_API_KEY,
+      "x-api-secret": process.env.FLOWRIX_API_SECRET,
+      "Origin": process.env.FLOWRIX_API_ORIGIN,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(body)
+  });
+  return subscribe;
+});

package/dist/runtime/server/api/v2/[...slug].d.ts

@@ -0,0 +1,3 @@
+export declare const Page: Map<any, any>;
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<unknown>>;
+export default _default;

package/dist/runtime/server/api/v2/[...slug].js

@@ -0,0 +1,9 @@
+import { defineEventHandler } from "h3";
+import { flowrixApi } from "../../../middleware/flowrix.js";
+export const Page = /* @__PURE__ */ new Map();
+export default defineEventHandler(async (event) => {
+  const slug = event.context.params._;
+  const page = await flowrixApi.get(`permalink/${slug}`, "", "v2");
+  Page.set(slug, page);
+  return page;
+});

package/dist/runtime/server/tsconfig.json

@@ -0,0 +1,3 @@
+{
+  "extends": "../../../.nuxt/tsconfig.server.json",
+}

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

@@ -0,0 +1,99 @@
+interface CalendarItem {
+    id: number;
+    date: string;
+    available: boolean;
+    [key: string]: any;
+}
+interface TimeSlot {
+    id: number;
+    time: string;
+    available: boolean;
+    [key: string]: any;
+}
+interface BookingData {
+    calendar_id: number;
+    booking_date: string;
+    time_slot: string;
+    [key: string]: any;
+}
+interface BookingState {
+    calendar: CalendarItem[];
+    timeSlots: TimeSlot[];
+    selectedDate: string | null;
+    responseData: any;
+    errorResponseData: any;
+    isLoading: boolean;
+}
+export declare const useBookingStore: import("pinia").StoreDefinition<"booking", BookingState, {
+    availableCalendarDates: (state: {
+        calendar: {
+            [x: string]: any;
+            id: number;
+            date: string;
+            available: boolean;
+        }[];
+        timeSlots: {
+            [x: string]: any;
+            id: number;
+            time: string;
+            available: boolean;
+        }[];
+        selectedDate: string | null;
+        responseData: any;
+        errorResponseData: any;
+        isLoading: boolean;
+    } & import("pinia").PiniaCustomStateProperties<BookingState>) => {
+        [x: string]: any;
+        id: number;
+        date: string;
+        available: boolean;
+    }[];
+    availableTimeSlots: (state: {
+        calendar: {
+            [x: string]: any;
+            id: number;
+            date: string;
+            available: boolean;
+        }[];
+        timeSlots: {
+            [x: string]: any;
+            id: number;
+            time: string;
+            available: boolean;
+        }[];
+        selectedDate: string | null;
+        responseData: any;
+        errorResponseData: any;
+        isLoading: boolean;
+    } & import("pinia").PiniaCustomStateProperties<BookingState>) => {
+        [x: string]: any;
+        id: number;
+        time: string;
+        available: boolean;
+    }[];
+    hasErrors: (state: {
+        calendar: {
+            [x: string]: any;
+            id: number;
+            date: string;
+            available: boolean;
+        }[];
+        timeSlots: {
+            [x: string]: any;
+            id: number;
+            time: string;
+            available: boolean;
+        }[];
+        selectedDate: string | null;
+        responseData: any;
+        errorResponseData: any;
+        isLoading: boolean;
+    } & import("pinia").PiniaCustomStateProperties<BookingState>) => boolean;
+}, {
+    getCalendar(calendarId?: number): Promise<void>;
+    fetchTimeSlots(bookingDate: string, calendarId?: number): Promise<void>;
+    saveBookingSlot(bookingData: BookingData): Promise<any>;
+    clearErrors(): void;
+    resetBooking(): void;
+}>;
+export {};

package/dist/runtime/stores/Booking.js

@@ -0,0 +1,96 @@
+import { defineStore } from "pinia";
+import { useApi } from "../utils/api.js";
+export const useBookingStore = defineStore("booking", {
+  state: () => ({
+    calendar: [],
+    timeSlots: [],
+    selectedDate: null,
+    responseData: null,
+    errorResponseData: null,
+    isLoading: false
+  }),
+  actions: {
+    async getCalendar(calendarId = 4) {
+      try {
+        this.isLoading = true;
+        const { get } = useApi();
+        const apiUrl = "services/calendar";
+        const params = {
+          calendar: calendarId
+        };
+        const response = await get(apiUrl, { params });
+        if (response) {
+          this.calendar = response.data || response;
+        }
+      } catch (error) {
+        console.error("Error fetching calendar:", error);
+        this.errorResponseData = error;
+      } finally {
+        this.isLoading = false;
+      }
+    },
+    async fetchTimeSlots(bookingDate, calendarId = 4) {
+      try {
+        this.isLoading = true;
+        this.selectedDate = bookingDate;
+        const { get } = useApi();
+        const apiUrl = "services/gettimeslots";
+        const params = {
+          calendar: calendarId,
+          booking_date: bookingDate
+        };
+        const response = await get(apiUrl, { params });
+        if (response) {
+          this.timeSlots = response.data || response;
+        }
+      } catch (error) {
+        console.error("Error fetching time slots:", error);
+        this.errorResponseData = error;
+      } finally {
+        this.isLoading = false;
+      }
+    },
+    async saveBookingSlot(bookingData) {
+      try {
+        this.isLoading = true;
+        const { post } = useApi();
+        const apiUrl = "services/calendar/save";
+        const response = await post(apiUrl, bookingData);
+        if (response) {
+          this.responseData = response;
+          return response;
+        }
+      } catch (error) {
+        console.error("Error saving booking slot:", error);
+        this.errorResponseData = error;
+        throw error;
+      } finally {
+        this.isLoading = false;
+      }
+    },
+    // Clear error state
+    clearErrors() {
+      this.errorResponseData = null;
+    },
+    // Reset store state
+    resetBooking() {
+      this.calendar = [];
+      this.timeSlots = [];
+      this.selectedDate = null;
+      this.responseData = null;
+      this.errorResponseData = null;
+      this.isLoading = false;
+    }
+  },
+  getters: {
+    availableCalendarDates: (state) => {
+      return state.calendar.filter((item) => item.available);
+    },
+    availableTimeSlots: (state) => {
+      return state.timeSlots.filter((slot) => slot.available);
+    },
+    hasErrors: (state) => {
+      return !!state.errorResponseData;
+    }
+  }
+});

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

@@ -0,0 +1,67 @@
+export interface CouponData {
+    remove?: number;
+    code: string;
+}
+export interface CheckoutSession {
+    cart: Record<string, CartItem> | undefined;
+    vouchercodes: string[];
+    fields?: Record<string, any>;
+    code: string;
+    abndToken?: string;
+}
+export interface CartItem {
+    cart: Record<string, CartItem> | undefined;
+    vouchercodes: string[];
+    fields?: CheckoutSession["fields"];
+    code: string;
+    qty?: number;
+    abndToken?: string;
+}
+export interface ApplyCoupon {
+    cart: Record<string, CartItem> | undefined;
+    vouchercodes: string[];
+    fields?: CheckoutSession["fields"];
+    code: string;
+    abndToken?: string;
+}
+export interface CartData {
+    rowId: string;
+    cart: Record<string, CartItem> | undefined;
+    qty?: number;
+    abndToken?: string;
+    deliverymethod?: number | string;
+    shipping_state?: string | number;
+    shipping_postcode?: number;
+    shipping_country?: string | number;
+    shippingmethod?: string | number;
+    vouchercodes?: string[];
+}
+export interface FormData {
+    cart: Record<string, CartItem> | undefined;
+    qty: number;
+    rowId: string;
+    data?: Record<string, any>;
+    abndToken?: string;
+    deliverymethod?: number | string;
+    shipping_state?: string | number;
+    shipping_postcode?: number;
+    shipping_country?: string | number;
+    shippingmethod?: string | number;
+    vouchercodes?: string[];
+}
+export interface CartState {
+    cart: {
+        items?: Record<string, CartItem>;
+        totals?: Record<string, any>;
+        abndToken?: string;
+        fields?: CheckoutSession["fields"];
+    };
+    lastitem?: any;
+    activeService: [];
+    coupon: string[];
+    data: [];
+    responseData: [];
+    errorResponseData: Record<string, any>;
+    addedResponse: string;
+}
+export declare const useCartStore: import("pinia").StoreDefinition<"cart", CartState, {}, {}>;