flowrix 1.0.1-beta.9 → 1.0.1-beta.92

package/dist/runtime/server/api/nav/[id]/links.js

@@ -1,19 +1,53 @@
-import { defineEventHandler, setResponseStatus, getRouterParam } from "h3";
-import { $fetch } from "ofetch";
+import { defineEventHandler, getRouterParam, getQuery, createError, getCookie } from "h3";
+import { writeFile, mkdir, readFile } from "fs/promises";
+import { join } from "path";
+import { flowrixApi } from "../../../../middleware/flowrix.js";
+import { useRuntimeConfig } from "#imports";
+const CACHE_DIR = join("/tmp", ".cache", "nitro", "navigation");
+export const menuCache = /* @__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 id = getRouterParam(event, "id");
+  const slug = getRouterParam(event, "id");
+  const customerType = getCookie(event, "customertype") || "";
+  let query = getQuery(event);
+  if (!slug) {
+    throw createError({ statusCode: 400, statusMessage: "Missing slug parameter" });
+  }
+  if (!/^[a-zA-Z0-9-_]+$/.test(slug)) {
+  }
+  const cacheKey = `${slug}-${JSON.stringify(query)}`;
+  const fileName = cacheKey.replace(/[^a-zA-Z0-9-_]/g, "_");
+  const filePath = join(CACHE_DIR, `${fileName}-${customerType}.json`);
   try {
-    const response = await $fetch(`${process.env.FLOWRIX_API_BASE}nav/${id}/links`, {
-      method: "GET",
-      headers: {
-        "x-api-key": process.env.FLOWRIX_API_KEY,
-        "x-api-secret": process.env.FLOWRIX_API_SECRET,
-        "Origin": process.env.FLOWRIX_API_ORIGIN
-      }
-    });
-    return response;
+    const fileContent = await readFile(filePath, "utf-8");
+    const menu = JSON.parse(fileContent);
+    return menu;
   } catch (error) {
-    setResponseStatus(event, 500);
-    return { success: false, error: error.message };
+  }
+  try {
+    const config = useRuntimeConfig();
+    const rawCookies = event.req.headers.cookie || "";
+    const apiConfig = {
+      ...config,
+      cookies: rawCookies
+    };
+    const menu = await flowrixApi.get(`nav/${slug}/links`, apiConfig, {});
+    if (config.public.FLOWRIX_CACHE == true) {
+      await ensureCacheDir();
+      await writeFile(filePath, JSON.stringify(menu, null, 2), "utf-8");
+    }
+    return menu;
+  } catch (error) {
+    throw createError({
+      statusCode: 500,
+      statusMessage: `Failed to fetch menu for id = ${slug}`,
+      data: error.message
+    });
   }
 });

package/dist/runtime/server/api/page/{[slug].js → [...slug].js}

@@ -1,8 +1,9 @@
-import { defineEventHandler, getRouterParam, getQuery, createError, readBody } from "h3";
-import { $fetch } from "ofetch";
+import { defineEventHandler, getQuery, createError, readBody, getCookie } from "h3";
 import { writeFile, mkdir, readFile } from "fs/promises";
 import { join } from "path";
-const CACHE_DIR = join(process.cwd(), ".nuxt", "cache", "nitro", "pages");
+import { useRuntimeConfig } from "#imports";
+import { flowrixApi } from "../../../middleware/flowrix.js";
+const CACHE_DIR = join("/tmp", ".cache", "nitro", "pages");
 export const pageCache = /* @__PURE__ */ new Map();
 async function ensureCacheDir() {
   try {
@@ -12,18 +13,16 @@ async function ensureCacheDir() {
   }
 }
 export default defineEventHandler(async (event) => {
-  const slug = getRouterParam(event, "slug");
+  const slug = event.context.params._;
+  const customerType = getCookie(event, "customertype") || "";
   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`);
+  const filePath = join(CACHE_DIR, `${fileName}-${customerType}.json`);
   try {
     const fileContent = await readFile(filePath, "utf-8");
     const page = JSON.parse(fileContent);
@@ -31,15 +30,17 @@ export default defineEventHandler(async (event) => {
   } catch (error) {
   }
   try {
-    const page = await $fetch(`${process.env.FLOWRIX_API_BASE}page/${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(page, null, 2), "utf-8");
+    const config = useRuntimeConfig();
+    const rawCookies = event.req.headers.cookie || "";
+    const apiConfig = {
+      ...config,
+      cookies: rawCookies
+    };
+    const page = await flowrixApi.get(`page/${slug}`, apiConfig, {});
+    if (config.public.FLOWRIX_CACHE == true) {
+      await ensureCacheDir();
+      await writeFile(filePath, JSON.stringify(page, null, 2), "utf-8");
+    }
     return page;
   } catch (error) {
     throw createError({

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

@@ -1,8 +1,9 @@
-import { defineEventHandler, getQuery, createError, readBody } from "h3";
+import { defineEventHandler, getQuery, createError, readBody, getCookie } 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");
+import { useRuntimeConfig } from "#imports";
+const CACHE_DIR = join("/tmp", ".cache", "nitro", "products");
 export const productCache = /* @__PURE__ */ new Map();
 async function ensureCacheDir() {
   try {
@@ -13,14 +14,15 @@ async function ensureCacheDir() {
 }
 export default defineEventHandler(async (event) => {
   const slug = event.context.params._;
-  const query = getQuery(event);
+  const customerType = getCookie(event, "customertype") || "";
+  let 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`);
+  const filePath = join(CACHE_DIR, `${fileName}-${customerType}.json`);
   try {
     const fileContent = await readFile(filePath, "utf-8");
     const product = JSON.parse(fileContent);
@@ -28,11 +30,23 @@ export default defineEventHandler(async (event) => {
   } 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");
+    const config = useRuntimeConfig();
+    const rawCookies = event.req.headers.cookie || "";
+    const apiConfig = {
+      ...config,
+      cookies: rawCookies
+    };
+    query = {
+      ...query
+    };
+    const product = await flowrixApi.post(`product/${slug}`, apiConfig, {
+      body: JSON.stringify(body),
+      query
+    });
+    if (config.public.FLOWRIX_CACHE == true) {
+      await ensureCacheDir();
+      await writeFile(filePath, JSON.stringify(product, null, 2), "utf-8");
+    }
     return product;
   } catch (error) {
     throw createError({

package/dist/runtime/server/api/{v2/[...slug].d.ts → quickview/[slug].d.ts}

@@ -1,3 +1,2 @@
-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/quickview/[slug].js

@@ -0,0 +1,17 @@
+import { defineEventHandler, getRouterParam, readBody } from "h3";
+import { flowrixApi } from "../../../middleware/flowrix.js";
+import { useRuntimeConfig } from "#imports";
+export default defineEventHandler(async (event) => {
+  const slug = getRouterParam(event, "slug");
+  const body = await readBody(event);
+  const config = useRuntimeConfig();
+  const rawCookies = event.req.headers.cookie || "";
+  const apiConfig = {
+    ...config,
+    cookies: rawCookies
+  };
+  const quickview = await flowrixApi.post(`quickview/${slug}`, apiConfig, {
+    body: JSON.stringify(body)
+  });
+  return quickview;
+});

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

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

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

@@ -0,0 +1,18 @@
+import { defineEventHandler, setResponseStatus } from "h3";
+import { useRuntimeConfig } from "#imports";
+import { flowrixApi } from "../../middleware/flowrix.js";
+export default defineEventHandler(async (event) => {
+  try {
+    const config = useRuntimeConfig();
+    const rawCookies = event.req.headers.cookie || "";
+    const apiConfig = {
+      ...config,
+      cookies: rawCookies
+    };
+    const reviews = await flowrixApi.get(`reviews`, apiConfig, {});
+    return reviews;
+  } catch (error) {
+    setResponseStatus(event, 500);
+    return { success: false, error: error.message };
+  }
+});

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

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

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

@@ -0,0 +1,50 @@
+import { defineEventHandler, getQuery, createError, getCookie } from "h3";
+import { writeFile, mkdir, readFile } from "fs/promises";
+import { join } from "path";
+import { useRuntimeConfig } from "#imports";
+import { flowrixApi } from "../../middleware/flowrix.js";
+const CACHE_DIR = join("/tmp", ".cache", "nitro", "catalog");
+export const catelogCache = /* @__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) => {
+  let query = getQuery(event);
+  const customerType = getCookie(event, "customertype") || "";
+  const cacheKey = `samples-${JSON.stringify(query)}`;
+  const fileName = cacheKey.replace(/[^a-zA-Z0-9-_]/g, "_");
+  const filePath = join(CACHE_DIR, `${fileName}-${customerType}.json`);
+  try {
+    const fileContent = await readFile(filePath, "utf-8");
+    const catelog = JSON.parse(fileContent);
+    return catelog;
+  } catch (error) {
+  }
+  try {
+    const config = useRuntimeConfig();
+    const rawCookies = event.req.headers.cookie || "";
+    const apiConfig = {
+      ...config,
+      cookies: rawCookies
+    };
+    query = {
+      ...query
+    };
+    const samples = await flowrixApi.get(`samples`, apiConfig, { query });
+    if (config.public.FLOWRIX_CACHE == true) {
+      await ensureCacheDir();
+      await writeFile(filePath, JSON.stringify(samples, null, 2), "utf-8");
+    }
+    return samples;
+  } catch (error) {
+    throw createError({
+      statusCode: 500,
+      statusMessage: `Failed to fetch samples`,
+      data: error.message
+    });
+  }
+});

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

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

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

@@ -0,0 +1,50 @@
+import { defineEventHandler, getQuery, createError, getCookie } from "h3";
+import { writeFile, mkdir, readFile } from "fs/promises";
+import { join } from "path";
+import { useRuntimeConfig } from "#imports";
+import { flowrixApi } from "../../middleware/flowrix.js";
+const CACHE_DIR = join("/tmp", ".cache", "nitro", "catalog");
+export const catelogCache = /* @__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) => {
+  let query = getQuery(event);
+  const customerType = getCookie(event, "customertype") || "";
+  const cacheKey = `search-${JSON.stringify(query)}`;
+  const fileName = cacheKey.replace(/[^a-zA-Z0-9-_]/g, "_");
+  const filePath = join(CACHE_DIR, `${fileName}-${customerType}.json`);
+  try {
+    const fileContent = await readFile(filePath, "utf-8");
+    const catelog = JSON.parse(fileContent);
+    return catelog;
+  } catch (error) {
+  }
+  try {
+    const config = useRuntimeConfig();
+    const rawCookies = event.req.headers.cookie || "";
+    const apiConfig = {
+      ...config,
+      cookies: rawCookies
+    };
+    query = {
+      ...query
+    };
+    const search = await flowrixApi.get(`search`, apiConfig, { query });
+    if (config.public.FLOWRIX_CACHE == true) {
+      await ensureCacheDir();
+      await writeFile(filePath, JSON.stringify(search, null, 2), "utf-8");
+    }
+    return search;
+  } catch (error) {
+    throw createError({
+      statusCode: 500,
+      statusMessage: `Failed to fetch catelog for slug: ${slug}`,
+      data: error.message
+    });
+  }
+});

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

@@ -1,8 +1,9 @@
-import { defineEventHandler, getRouterParam, getQuery, createError, readBody } from "h3";
-import { $fetch } from "ofetch";
+import { defineEventHandler, getRouterParam, getQuery, createError, readBody, getCookie } from "h3";
 import { writeFile, mkdir, readFile } from "fs/promises";
 import { join } from "path";
-const CACHE_DIR = join(process.cwd(), ".nuxt", "cache", "nitro", "services");
+import { useRuntimeConfig } from "#imports";
+import { flowrixApi } from "../../../middleware/flowrix.js";
+const CACHE_DIR = join("/tmp", ".cache", "nitro", "services");
 export const serviceCache = /* @__PURE__ */ new Map();
 async function ensureCacheDir() {
   try {
@@ -13,6 +14,7 @@ async function ensureCacheDir() {
 }
 export default defineEventHandler(async (event) => {
   const slug = getRouterParam(event, "slug");
+  const customerType = getCookie(event, "customertype") || "";
   const query = getQuery(event);
   const body = await readBody(event);
   if (!slug) {
@@ -23,7 +25,7 @@ export default defineEventHandler(async (event) => {
   }
   const cacheKey = `${slug}-${JSON.stringify(query)}`;
   const fileName = cacheKey.replace(/[^a-zA-Z0-9-_]/g, "_");
-  const filePath = join(CACHE_DIR, `${fileName}.json`);
+  const filePath = join(CACHE_DIR, `${fileName}-${customerType}.json`);
   try {
     const fileContent = await readFile(filePath, "utf-8");
     const service = JSON.parse(fileContent);
@@ -31,15 +33,17 @@ export default defineEventHandler(async (event) => {
   } 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");
+    const config = useRuntimeConfig();
+    const rawCookies = event.req.headers.cookie || "";
+    const apiConfig = {
+      ...config,
+      cookies: rawCookies
+    };
+    const service = await flowrixApi.get(`services/${slug}`, apiConfig, {});
+    if (config.public.FLOWRIX_CACHE == true) {
+      await ensureCacheDir();
+      await writeFile(filePath, JSON.stringify(service, null, 2), "utf-8");
+    }
     return service;
   } catch (error) {
     throw createError({

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

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

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

@@ -1,25 +1,23 @@
+import { useRuntimeConfig } from "#imports";
 import { defineEventHandler, readBody } from "h3";
+import { flowrixApi } from "../../../middleware/flowrix.js";
 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"
-      },
+    const config = useRuntimeConfig();
+    const rawCookies = event.req.headers.cookie || "";
+    const apiConfig = {
+      ...config,
+      cookies: rawCookies
+    };
+    const response = await flowrixApi.post(`services/availability`, apiConfig, {
       body: JSON.stringify(body)
     });
-    const responseData = await response.json();
-    return responseData;
+    return response;
   } catch (error) {
-    console.error("Error in service availability:", error);
     return {
       status: "Error",
-      statusCode: 500,
+      statusCode: 422,
       message: "Internal server error",
       error: error.message || "Unknown error"
     };

package/dist/runtime/server/api/service/getall.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/getall.js

@@ -0,0 +1,55 @@
+import { defineEventHandler, getQuery, createError, readBody, getCookie } from "h3";
+import { writeFile, mkdir, readFile } from "fs/promises";
+import { join } from "path";
+import { useRuntimeConfig } from "#imports";
+import { flowrixApi } from "../../../middleware/flowrix.js";
+const CACHE_DIR = join("/tmp", ".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 = "all";
+  const customerType = getCookie(event, "customertype") || "";
+  let 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}-${customerType}.json`);
+  try {
+    const fileContent = await readFile(filePath, "utf-8");
+    const service = JSON.parse(fileContent);
+    return service;
+  } catch (error) {
+  }
+  try {
+    const config = useRuntimeConfig();
+    const rawCookies = event.req.headers.cookie || "";
+    const apiConfig = {
+      ...config,
+      cookies: rawCookies
+    };
+    const service = await flowrixApi.get(`services`, apiConfig, {});
+    if (config.public.FLOWRIX_CACHE == true) {
+      await ensureCacheDir();
+      await writeFile(filePath, JSON.stringify(service, null, 2), "utf-8");
+    }
+    return service;
+  } catch (error) {
+    throw createError({
+      statusCode: 500,
+      statusMessage: `Failed to fetch services`,
+      data: error.message
+    });
+  }
+});

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

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

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

@@ -0,0 +1,50 @@
+import { defineEventHandler, getQuery, createError, getCookie } from "h3";
+import { writeFile, mkdir, readFile } from "fs/promises";
+import { join } from "path";
+import { useRuntimeConfig } from "#imports";
+import { flowrixApi } from "../../middleware/flowrix.js";
+const CACHE_DIR = join("/tmp", ".cache", "nitro", "catalog");
+export const catelogCache = /* @__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) => {
+  let query = getQuery(event);
+  const customerType = getCookie(event, "customertype") || "";
+  const cacheKey = `search-${JSON.stringify(query)}`;
+  const fileName = cacheKey.replace(/[^a-zA-Z0-9-_]/g, "_");
+  const filePath = join(CACHE_DIR, `${fileName}-${customerType}.json`);
+  try {
+    const fileContent = await readFile(filePath, "utf-8");
+    const catelog = JSON.parse(fileContent);
+    return catelog;
+  } catch (error) {
+  }
+  try {
+    const config = useRuntimeConfig();
+    const rawCookies = event.req.headers.cookie || "";
+    const apiConfig = {
+      ...config,
+      cookies: rawCookies
+    };
+    query = {
+      ...query
+    };
+    const search = await flowrixApi.get(`search`, apiConfig, { query });
+    if (config.public.FLOWRIX_CACHE == true) {
+      await ensureCacheDir();
+      await writeFile(filePath, JSON.stringify(search, null, 2), "utf-8");
+    }
+    return search;
+  } catch (error) {
+    throw createError({
+      statusCode: 500,
+      statusMessage: `Failed to fetch catelog for slug: ${slug}`,
+      data: error.message
+    });
+  }
+});

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

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

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

@@ -1,16 +1,21 @@
-import { defineEventHandler, readBody } from "h3";
-import { $fetch } from "ofetch";
+import { defineEventHandler, readBody, setResponseStatus } from "h3";
+import { flowrixApi } from "../../middleware/flowrix.js";
+import { useRuntimeConfig } from "#imports";
 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;
+  try {
+    const body = await readBody(event);
+    const config = useRuntimeConfig();
+    const rawCookies = event.req.headers.cookie || "";
+    const apiConfig = {
+      ...config,
+      cookies: rawCookies
+    };
+    const subscribe = await flowrixApi.post(`subscribe`, apiConfig, {
+      body: JSON.stringify(body)
+    });
+    return subscribe;
+  } catch (error) {
+    setResponseStatus(event, 500);
+    return { success: false, error: error.message };
+  }
 });

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

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

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

@@ -0,0 +1,16 @@
+import { defineEventHandler } from "h3";
+import { flowrixApi } from "../../../middleware/flowrix.js";
+import { useRuntimeConfig } from "#imports";
+export default defineEventHandler(async (event) => {
+  const slug = event.context.params._;
+  const config = useRuntimeConfig();
+  const rawCookies = event.req.headers.cookie || "";
+  const apiConfig = {
+    ...config,
+    cookies: rawCookies
+  };
+  const page = await flowrixApi.get(`permalink/${slug}`, apiConfig);
+  if (page.status === "Success" && page.data.type === "Redirect") {
+  }
+  return page;
+});

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

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