flowrix 1.0.0

package/dist/runtime/server/api/auth/login.js

@@ -0,0 +1,69 @@
+import { defineEventHandler, readBody, createError } from "h3";
+export default defineEventHandler(async (event) => {
+  try {
+    const body = await readBody(event);
+    const { email, password } = body;
+    if (!email || !password) {
+      throw createError({
+        statusCode: 400,
+        statusMessage: "Email and password are required"
+      });
+    }
+    const config = useRuntimeConfig();
+    const apiBase = config.apiBase;
+    const apiKey = config.apiKey;
+    const apiSecret = config.apiSecret;
+    const apiOrigin = config.apiOrigin;
+    const response = await fetch(`${process.env.FLOWRIX_API_BASE}login/`, {
+      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({ email, password })
+    });
+    if (!response.ok) {
+      let errorMessage = "Login failed";
+      try {
+        const errorData = await response.json();
+        console.error("Error response data:", errorData);
+        if (errorData.message) {
+          if (Array.isArray(errorData.message)) {
+            errorMessage = errorData.message.join(", ");
+          } else if (typeof errorData.message === "object") {
+            errorMessage = errorData.message.email || Object.values(errorData.message)[0] || errorMessage;
+          } else {
+            errorMessage = errorData.message;
+          }
+        }
+      } catch (parseError) {
+        console.error("Failed to parse error response:", parseError);
+        errorMessage = `HTTP ${response.status}: ${response.statusText}`;
+      }
+      throw createError({
+        statusCode: response.status,
+        statusMessage: errorMessage
+      });
+    }
+    const data = await response.json();
+    let user;
+    let token;
+    user = data.data.user;
+    token = data.data.access_token;
+    return {
+      user,
+      token
+    };
+  } catch (error) {
+    console.error("Login error:", error);
+    if (error.statusCode || error.status) {
+      throw error;
+    }
+    throw createError({
+      statusCode: 500,
+      statusMessage: error.message || "Internal server error"
+    });
+  }
+});

package/dist/runtime/server/api/auth/logout.d.ts

@@ -0,0 +1,5 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<{
+    success: boolean;
+    message: string;
+}>>;
+export default _default;

package/dist/runtime/server/api/auth/logout.js

@@ -0,0 +1,23 @@
+import { defineEventHandler, getCookie, deleteCookie } from "h3";
+export default defineEventHandler(async (event) => {
+  const accessTok = getCookie(event, "auth.token");
+  try {
+    await $fetch(`${process.env.FLOWRIX_API_BASE}customer/logout`, {
+      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,
+        "Authorization": `Bearer ${accessTok || ""}`
+      }
+    });
+    deleteCookie(event, "auth.token");
+    deleteCookie(event, "auth.refreshToken");
+    deleteCookie(event, "auth.user");
+    deleteCookie(event, "auth.session");
+    return { success: true, message: "Logout successful" };
+  } catch (error) {
+    console.error("Error customer logout:", error);
+    return { success: false, message: "Logout failed" };
+  }
+});

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

@@ -0,0 +1,51 @@
+import { defineEventHandler, readBody } from "h3";
+export default defineEventHandler(async (event) => {
+  const body = await readBody(event);
+  const { firstname, lastname, mobile, email, email_confirmation, password, password_confirmation } = body;
+  try {
+    const response = await fetch(`${process.env.FLOWRIX_API_BASE}customer/create`, {
+      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({ firstname, lastname, mobile, email, email_confirmation, password, password_confirmation })
+    });
+    if (!response.ok) {
+      let errorMessage = {};
+      let errorData;
+      try {
+        errorData = await response.json();
+        console.error("Error response data:", errorData);
+        if (errorData.message) {
+          errorMessage = errorData.message?.email || errorData.message;
+        }
+      } catch (parseError) {
+        errorMessage = "Failed to parse error details.";
+        console.error("Error parsing JSON:", parseError);
+        errorData = { message: errorMessage };
+      }
+      throw createError({
+        status: response.status,
+        message: errorMessage,
+        // Use the more specific errorMessage
+        data: { message: errorMessage, errorData }
+        // Include both messages and the raw error
+      });
+    }
+    const data = await response.json();
+    return data.data;
+  } catch (error) {
+    const statusCode = error.status || 500;
+    const message = error.message || "An unexpected error occurred";
+    const errorData = error.data || { message };
+    console.error("Final Error:", { statusCode, message, errorData });
+    throw createError({
+      status: statusCode,
+      message,
+      data: errorData
+    });
+  }
+});

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

@@ -0,0 +1,46 @@
+import { defineEventHandler, getCookie, createError } from "h3";
+export default defineEventHandler(async (event) => {
+  try {
+    const authHeader = getHeader(event, "authorization");
+    const token = authHeader?.replace("Bearer ", "") || getCookie(event, "nuxt-auth.token");
+    if (!token) {
+      throw createError({
+        statusCode: 401,
+        statusMessage: "No token provided"
+      });
+    }
+    const config = useRuntimeConfig();
+    const apiBase = config.apiBase;
+    const apiKey = config.apiKey;
+    const apiSecret = config.apiSecret;
+    const apiOrigin = config.apiOrigin;
+    const response = await fetch(`${apiBase}user/session`, {
+      method: "GET",
+      headers: {
+        "x-api-key": apiKey,
+        "x-api-secret": apiSecret,
+        "Origin": apiOrigin || "",
+        "Authorization": `Bearer ${token}`,
+        "Content-Type": "application/json",
+        "Accept": "application/json"
+      }
+    });
+    if (!response.ok) {
+      throw createError({
+        statusCode: response.status,
+        statusMessage: "Failed to get session"
+      });
+    }
+    const data = await response.json();
+    return data.data || data.user || data;
+  } catch (error) {
+    console.error("Session error:", error);
+    if (error.statusCode || error.status) {
+      throw error;
+    }
+    throw createError({
+      statusCode: 401,
+      statusMessage: "Invalid session"
+    });
+  }
+});

package/dist/runtime/server/api/auth/user/reset-password.d.ts

@@ -0,0 +1,5 @@
+interface APIResponse {
+    token: string;
+}
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<void | APIResponse>>;
+export default _default;

package/dist/runtime/server/api/auth/user/reset-password.js

@@ -0,0 +1,40 @@
+import { defineEventHandler, readBody, getCookie, sendError } from "h3";
+export default defineEventHandler(async (event) => {
+  const body = await readBody(event);
+  const { password, password_confirmation, token } = body;
+  try {
+    const auth_token = getCookie(event, "token");
+    const response = await fetch(`${process.env.FLOWRIX_API_BASE}reset-password/`, {
+      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",
+        // <--- CHANGE THIS
+        Authorization: `Bearer ${auth_token}`
+        // Use the token from the cookie
+      },
+      body: JSON.stringify({ "token": auth_token, password, password_confirmation })
+    });
+    if (!response.ok) {
+      let errorMessage = ``;
+      const errorData = await response.json();
+      errorMessage += errorData.message?.password || errorData.message.token;
+      throw sendError(event, {
+        statusCode: 400,
+        statusMessage: errorMessage,
+        data: errorMessage
+      });
+    }
+    const data = await response.json();
+    return data;
+  } catch (error) {
+    return sendError(event, {
+      statusCode: 500,
+      statusMessage: `Login failed: ${error.message || "An unexpected error occurred"}`,
+      data: { message: error.message || "An unexpected error occurred" }
+      // Include in data as well
+    });
+  }
+});

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

@@ -0,0 +1,43 @@
+import { defineEventHandler, getHeader, createError } from "h3";
+export default defineEventHandler(async (event) => {
+  const authHeader = getHeader(event, "authorization");
+  try {
+    const response = await fetch(`${process.env.FLOWRIX_API_BASE}customer/profile`, {
+      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,
+        Authorization: authHeader
+        // Use the authorization header if available
+      }
+      // body: JSON.stringify({ email, password }),
+    });
+    if (!response.ok) {
+      let errorMessage = ``;
+      try {
+        const errorData = await response.json();
+        if (errorData.message) {
+          errorMessage += errorData.message?.email || errorData.message;
+        }
+      } catch (parseError) {
+        errorMessage += "Failed to parse error details.";
+      }
+      throw createError({
+        status: 400,
+        statusMessage: "Bad Request",
+        message: "Invalid user input",
+        data: { field: "email" }
+      });
+    }
+    const data = await response.json();
+    return data.data;
+  } catch (error) {
+    throw createError({
+      status: 400,
+      statusMessage: "Bad Request",
+      message: "Invalid user input",
+      data: { field: "email" }
+    });
+  }
+});

package/dist/runtime/server/api/auth/user/verify-token.d.ts

@@ -0,0 +1,6 @@
+interface APIResponse {
+    token: string;
+    data: string;
+}
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<APIResponse>>;
+export default _default;

package/dist/runtime/server/api/auth/user/verify-token.js

@@ -0,0 +1,50 @@
+import { defineEventHandler, readBody, setCookie, createError } from "h3";
+export default defineEventHandler(async (event) => {
+  const body = await readBody(event);
+  const { email, token } = body;
+  try {
+    const response = await fetch(`${process.env.FLOWRIX_API_BASE}verify-token/`, {
+      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({ email, token })
+    });
+    if (!response.ok) {
+      let errorMessage = ``;
+      try {
+        const errorData = await response.json();
+        console.error("Error response data:", errorData.message);
+        if (errorData.message) {
+          errorMessage += errorData.message?.email || errorData.message;
+        }
+      } catch (parseError) {
+        errorMessage += "Failed to parse error details.";
+      }
+      throw createError({
+        status: 400,
+        statusMessage: "Bad Request",
+        message: "Invalid user input",
+        data: { field: "email" }
+      });
+    }
+    const data = await response.json();
+    setCookie(event, "token", data?.data, {
+      httpOnly: true,
+      secure: process.env.NODE_ENV === "production",
+      path: "/",
+      sameSite: "lax"
+    });
+    return data;
+  } catch (error) {
+    throw createError({
+      status: 400,
+      statusMessage: "Bad Request",
+      message: "Invalid user input",
+      data: { field: "email" }
+    });
+  }
+});

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

@@ -0,0 +1,41 @@
+import { defineEventHandler, createError } 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", "extra");
+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) => {
+  const fileName = "banners";
+  const filePath = join(CACHE_DIR, `${fileName}.json`);
+  try {
+    const fileContent = await readFile(filePath, "utf-8");
+    const catelog = JSON.parse(fileContent);
+    return catelog;
+  } catch (error) {
+  }
+  try {
+    const banners = await $fetch(`${process.env.FLOWRIX_API_BASE}banners`, {
+      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(banners, null, 2), "utf-8");
+    return banners;
+  } catch (error) {
+    throw createError({
+      statusCode: 500,
+      statusMessage: `Failed to fetch catelog for slug: ${slug}`,
+      data: error.message
+    });
+  }
+});

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

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

package/dist/runtime/server/api/blog/[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", "blogs");
+export const blogCache = /* @__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 blog = JSON.parse(fileContent);
+    return blog;
+  } catch (error) {
+  }
+  try {
+    const blog = await $fetch(`${process.env.FLOWRIX_API_BASE}posts/${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(blog, null, 2), "utf-8");
+    return blog;
+  } catch (error) {
+    throw createError({
+      statusCode: 500,
+      statusMessage: `Failed to fetch blog for slug: ${slug}`,
+      data: error.message
+    });
+  }
+});

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

@@ -0,0 +1,17 @@
+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}posts`, {
+    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
+    },
+    query
+  });
+  return page;
+});

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

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

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

@@ -0,0 +1,58 @@
+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", "brands");
+export const brandCache = /* @__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);
+  const isclearcashe = query.clearcache || false;
+  delete query.clearcache;
+  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`);
+  if (!isclearcashe) {
+    try {
+      const fileContent = await readFile(filePath, "utf-8");
+      const brand = JSON.parse(fileContent);
+      return brand;
+    } catch (error) {
+    }
+  }
+  try {
+    const brand = await $fetch(`${process.env.FLOWRIX_API_BASE}brands/${slug}`, {
+      query,
+      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
+      },
+      body: JSON.stringify(body)
+    });
+    await ensureCacheDir();
+    await writeFile(filePath, JSON.stringify(brand, null, 2), "utf-8");
+    return brand;
+  } catch (error) {
+    throw createError({
+      statusCode: 500,
+      statusMessage: `Failed to fetch brand for slug: ${slug}`,
+      data: error.message
+    });
+  }
+});

package/dist/runtime/server/api/cart/[slug]/add.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/cart/[slug]/add.js

@@ -0,0 +1,21 @@
+import { defineEventHandler, getRouterParam, setResponseStatus, readBody } from "h3";
+import { $fetch } from "ofetch";
+export default defineEventHandler(async (event) => {
+  const slug = getRouterParam(event, "slug");
+  const body = await readBody(event);
+  try {
+    const productResponse = await $fetch(`${process.env.FLOWRIX_API_BASE}cart/${slug}/add`, {
+      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
+      },
+      body
+    });
+    return productResponse;
+  } catch (error) {
+    setResponseStatus(event, 500);
+    return { success: false, error: error.message };
+  }
+});

package/dist/runtime/server/api/cart/[slug]/update.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/cart/[slug]/update.js

@@ -0,0 +1,21 @@
+import { defineEventHandler, getRouterParam, setResponseStatus, readBody } from "h3";
+import { $fetch } from "ofetch";
+export default defineEventHandler(async (event) => {
+  const slug = getRouterParam(event, "slug");
+  const body = await readBody(event);
+  try {
+    const productResponse = await $fetch(`${process.env.FLOWRIX_API_BASE}cart/${slug}/update`, {
+      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
+      },
+      body
+    });
+    return productResponse;
+  } catch (error) {
+    setResponseStatus(event, 500);
+    return { success: false, error: error.message };
+  }
+});

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

@@ -0,0 +1,21 @@
+import { defineEventHandler, getRouterParam, setResponseStatus, readBody } from "h3";
+import { $fetch } from "ofetch";
+export default defineEventHandler(async (event) => {
+  const slug = getRouterParam(event, "slug");
+  const body = await readBody(event);
+  try {
+    const productResponse = await $fetch(`${process.env.FLOWRIX_API_BASE}cart/remove`, {
+      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
+      },
+      body
+    });
+    return productResponse;
+  } catch (error) {
+    setResponseStatus(event, 500);
+    return { success: false, error: error.message };
+  }
+});

package/dist/runtime/server/api/cart/service/[slug]/add.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/cart/service/[slug]/add.js

@@ -0,0 +1,16 @@
+import { defineEventHandler } from "h3";
+import { $fetch } from "ofetch";
+export default defineEventHandler(async (event) => {
+  const slug = getRouterParam(event, "slug");
+  const body = await readBody(event);
+  const services = await $fetch(`${process.env.FLOWRIX_API_BASE}cart/service/${slug}/add`, {
+    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
+    },
+    body
+  });
+  return services;
+});

package/dist/runtime/server/api/catalog/categories.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;