flowrix 1.0.1-beta.85 → 1.0.1-beta.87

package/dist/runtime/server/api/customer/wishlist/getWishListItems.js

@@ -0,0 +1,21 @@
+import { defineEventHandler, getQuery, getCookie } from "h3";
+export default defineEventHandler(async (event) => {
+  const { listId } = getQuery(event);
+  const accessTok = getCookie(event, "auth.token");
+  try {
+    const response = await fetch(`${process.env.FLOWRIX_API_BASE}customer/wishlist/${listId}/products`, {
+      method: "GET",
+      headers: {
+        "x-public-key": process.env.FLOWRIX_API_KEY,
+        "x-api-secret": process.env.FLOWRIX_API_SECRET,
+        "Origin": process.env.FLOWRIX_API_ORIGIN,
+        "Authorization": `Bearer ${accessTok || ""}`
+      }
+    });
+    const responseData = await response.json();
+    return responseData;
+  } catch (error) {
+    console.error("Error in get wishlist items:", error);
+    return { error: "Failed to fetch wishlist items" };
+  }
+});

package/dist/runtime/server/api/customer/wishlist/updateWishList.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/customer/wishlist/updateWishList.js

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

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

@@ -0,0 +1,16 @@
+import { defineEventHandler, getCookie } from "h3";
+export default defineEventHandler(async (event) => {
+  const accessTok = getCookie(event, "auth.token");
+  try {
+    const response = await $fetch(`${process.env.FLOWRIX_API_BASE}products/featured`, {
+      headers: {
+        "x-public-key": process.env.FLOWRIX_API_KEY,
+        "x-api-secret": process.env.FLOWRIX_API_SECRET,
+        "Origin": process.env.FLOWRIX_API_ORIGIN,
+        "Authorization": `Bearer ${accessTok || ""}`
+      }
+    });
+    return response;
+  } catch (error) {
+  }
+});

package/dist/runtime/server/api/generate/robots.get.d.ts

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

package/dist/runtime/server/api/generate/robots.get.js

@@ -0,0 +1,20 @@
+import {
+  defineEventHandler,
+  setResponseStatus,
+  setHeader
+} from "h3";
+import { useRuntimeConfig } from "#imports";
+import { $fetch } from "ofetch";
+export default defineEventHandler(async (event) => {
+  try {
+    const config = useRuntimeConfig();
+    const fileUrl = config.public.FLOWRIX_CDN + "robots.txt";
+    const fileContent = await $fetch(fileUrl);
+    setHeader(event, "Content-Type", "text/plain; charset=utf-8");
+    return fileContent;
+  } catch (error) {
+    setResponseStatus(event, 404);
+    setHeader(event, "Content-Type", "text/plain; charset=utf-8");
+    return `File not found`;
+  }
+});

package/dist/runtime/server/api/generate/sitemap.get.d.ts

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

package/dist/runtime/server/api/generate/sitemap.get.js

@@ -0,0 +1,32 @@
+import {
+  defineEventHandler,
+  setResponseStatus,
+  setHeader
+} from "h3";
+import { useRuntimeConfig } from "#imports";
+import { $fetch } from "ofetch";
+export default defineEventHandler(async (event) => {
+  try {
+    let fullPath = event.path;
+    if (fullPath.startsWith("/")) {
+      fullPath = fullPath.slice(1);
+    }
+    const isGzip = fullPath.endsWith(".gz");
+    const config = useRuntimeConfig();
+    const cdnUrl = config.public.FLOWRIX_CDN + fullPath;
+    const buffer = await $fetch(cdnUrl, { responseType: "arrayBuffer" });
+    const data = Buffer.from(buffer);
+    if (isGzip) {
+      setHeader(event, "Content-Type", "application/xml; charset=utf-8");
+      setHeader(event, "Content-Encoding", "gzip");
+      return data;
+    }
+    setHeader(event, "Content-Type", "application/xml; charset=utf-8");
+    return data.toString();
+  } catch (error) {
+    setResponseStatus(event, 404);
+    setHeader(event, "Content-Type", "application/xml");
+    return `<?xml version="1.0"?>
+<error>File not found</error>`;
+  }
+});

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

@@ -0,0 +1,13 @@
+import { defineEventHandler } from "h3";
+import { $fetch } from "ofetch";
+export default defineEventHandler(async () => {
+  const location = await $fetch(`${process.env.FLOWRIX_API_BASE}ip/location`, {
+    method: "POST",
+    headers: {
+      "x-public-key": process.env.FLOWRIX_API_KEY,
+      "x-api-secret": process.env.FLOWRIX_API_SECRET,
+      "Origin": process.env.FLOWRIX_API_ORIGIN
+    }
+  });
+  return location;
+});

package/dist/runtime/server/api/nav/[id]/links.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/nav/[id]/links.js

@@ -0,0 +1,19 @@
+import { defineEventHandler, setResponseStatus, getRouterParam } from "h3";
+import { $fetch } from "ofetch";
+export default defineEventHandler(async (event) => {
+  const id = getRouterParam(event, "id");
+  try {
+    const response = await $fetch(`${process.env.FLOWRIX_API_BASE}nav/${id}/links`, {
+      method: "GET",
+      headers: {
+        "x-public-key": process.env.FLOWRIX_API_KEY,
+        "x-api-secret": process.env.FLOWRIX_API_SECRET,
+        "Origin": process.env.FLOWRIX_API_ORIGIN
+      }
+    });
+    return response;
+  } catch (error) {
+    setResponseStatus(event, 500);
+    return { success: false, error: error.message };
+  }
+});

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

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

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

@@ -0,0 +1,51 @@
+import { defineEventHandler, getQuery, createError, readBody, getCookie } from "h3";
+import { $fetch } from "ofetch";
+import { writeFile, mkdir, readFile } from "fs/promises";
+import { join } from "path";
+const CACHE_DIR = join("/tmp", ".cache", "nitro", "pages");
+export const pageCache = /* @__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 customerType = getCookie(event, "customertype") || "";
+  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}-${customerType}.json`);
+  try {
+    const fileContent = await readFile(filePath, "utf-8");
+    const page = JSON.parse(fileContent);
+    return page;
+  } catch (error) {
+  }
+  try {
+    const page = await $fetch(`${process.env.FLOWRIX_API_BASE}page/${slug}`, {
+      headers: {
+        "x-public-key": process.env.FLOWRIX_API_KEY,
+        "x-api-secret": process.env.FLOWRIX_API_SECRET,
+        "Origin": process.env.FLOWRIX_API_ORIGIN
+      }
+    });
+    if (config.public.FLOWRIX_CACHE == true) {
+      await ensureCacheDir();
+      await writeFile(filePath, JSON.stringify(page, null, 2), "utf-8");
+    }
+    return page;
+  } catch (error) {
+    throw createError({
+      statusCode: 500,
+      statusMessage: `Failed to fetch page for slug: ${slug}`,
+      data: error.message
+    });
+  }
+});

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

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

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

@@ -0,0 +1,49 @@
+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";
+import { useRuntimeConfig } from "#imports";
+const CACHE_DIR = join("/tmp", ".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 customerType = getCookie(event, "customertype") || "";
+  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}-${customerType}.json`);
+  try {
+    const fileContent = await readFile(filePath, "utf-8");
+    const product = JSON.parse(fileContent);
+    return product;
+  } catch (error) {
+  }
+  try {
+    const config = useRuntimeConfig();
+    const product = await flowrixApi.post(`product/${slug}`, config, {
+      body: JSON.stringify(body)
+    });
+    if (config.public.FLOWRIX_CACHE == true) {
+      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/quickview/[slug].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/quickview/[slug].js

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

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

@@ -0,0 +1,3 @@
+export declare const SamplesCache: 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,20 @@
+import { defineEventHandler, getQuery } from "h3";
+import { $fetch } from "ofetch";
+export const SamplesCache = /* @__PURE__ */ new Map();
+export default defineEventHandler(async (event) => {
+  const query = getQuery(event);
+  const cacheKey = `samples-${JSON.stringify(query)}`;
+  if (SamplesCache.has(cacheKey)) {
+    return SamplesCache.get(cacheKey);
+  }
+  const samples = await $fetch(`${process.env.FLOWRIX_API_BASE}samples`, {
+    headers: {
+      "x-public-key": process.env.FLOWRIX_API_KEY,
+      "x-api-secret": process.env.FLOWRIX_API_SECRET,
+      "Origin": process.env.FLOWRIX_API_ORIGIN
+    },
+    params: query
+  });
+  SamplesCache.set(cacheKey, samples);
+  return samples;
+});

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

@@ -0,0 +1,3 @@
+export declare const Page: 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,15 @@
+import { defineEventHandler, getQuery } from "h3";
+import { $fetch } from "ofetch";
+export const Page = /* @__PURE__ */ new Map();
+export default defineEventHandler(async (event) => {
+  const params = getQuery(event);
+  const search = await $fetch(`${process.env.FLOWRIX_API_BASE}search`, {
+    headers: {
+      "x-public-key": process.env.FLOWRIX_API_KEY,
+      "x-api-secret": process.env.FLOWRIX_API_SECRET,
+      "Origin": process.env.FLOWRIX_API_ORIGIN
+    },
+    params
+  });
+  return search;
+});

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,54 @@
+import { defineEventHandler, getRouterParam, getQuery, createError, readBody, getCookie } from "h3";
+import { $fetch } from "ofetch";
+import { writeFile, mkdir, readFile } from "fs/promises";
+import { join } from "path";
+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 = getRouterParam(event, "slug");
+  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}-${customerType}.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-public-key": process.env.FLOWRIX_API_KEY,
+        "x-api-secret": process.env.FLOWRIX_API_SECRET,
+        "Origin": process.env.FLOWRIX_API_ORIGIN
+      }
+    });
+    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 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-public-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/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,54 @@
+import { defineEventHandler, getQuery, createError, readBody, getCookie } from "h3";
+import { $fetch } from "ofetch";
+import { writeFile, mkdir, readFile } from "fs/promises";
+import { join } from "path";
+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") || "";
+  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}-${customerType}.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`, {
+      headers: {
+        "x-public-key": process.env.FLOWRIX_API_KEY,
+        "x-api-secret": process.env.FLOWRIX_API_SECRET,
+        "Origin": process.env.FLOWRIX_API_ORIGIN
+      }
+    });
+    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 Page: 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,15 @@
+import { defineEventHandler, getQuery } from "h3";
+import { $fetch } from "ofetch";
+export const Page = /* @__PURE__ */ new Map();
+export default defineEventHandler(async (event) => {
+  const query = getQuery(event);
+  const page = await $fetch(`${process.env.FLOWRIX_API_BASE}search`, {
+    headers: {
+      "x-public-key": process.env.FLOWRIX_API_KEY,
+      "x-api-secret": process.env.FLOWRIX_API_SECRET,
+      "Origin": process.env.FLOWRIX_API_ORIGIN
+    },
+    query
+  });
+  return page;
+});

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-public-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,11 @@
+import { defineEventHandler } from "h3";
+import { flowrixApi } from "../../../middleware/flowrix.js";
+import { useRuntimeConfig } from "#imports";
+export const Page = /* @__PURE__ */ new Map();
+export default defineEventHandler(async (event) => {
+  const slug = event.context.params._;
+  let config = useRuntimeConfig();
+  const page = await flowrixApi.get(`permalink/${slug}`, config);
+  Page.set(slug, page);
+  return page;
+});

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

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

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

@@ -0,0 +1,16 @@
+import { defineEventHandler, getRouterParam } from "h3";
+import { $fetch } from "ofetch";
+export const Page = /* @__PURE__ */ new Map();
+export default defineEventHandler(async (event) => {
+  const slug = getRouterParam(event, "slug");
+  const query = getQuery(event);
+  const page = await $fetch(`${process.env.FLOWRIX_API_BASE}contact-center/webforms/${query.id}/details`, {
+    headers: {
+      "x-public-key": process.env.FLOWRIX_API_KEY,
+      "x-api-secret": process.env.FLOWRIX_API_SECRET,
+      "Origin": process.env.FLOWRIX_API_ORIGIN
+    },
+    query
+  });
+  return page;
+});

package/dist/runtime/server/tsconfig.json

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