flowrix 1.0.1-beta.16 → 1.0.1-beta.160

package/dist/runtime/middleware/flowrixs3.js

@@ -0,0 +1,65 @@
+let S3Client = null;
+let GetObjectCommand = null;
+async function loadAWSSDK() {
+  if (!S3Client) {
+    const sdk = await import("@aws-sdk/client-s3");
+    S3Client = sdk.S3Client;
+    GetObjectCommand = sdk.GetObjectCommand;
+  }
+}
+let s3Client = null;
+async function getClient(config = {}) {
+  await loadAWSSDK();
+  if (s3Client) return s3Client;
+  const region = config?.S3_REGION || config.public?.S3_REGION || "us-east-1";
+  const accessKeyId = config?.S3_ACCESS_KEY_ID || "";
+  const secretAccessKey = config?.S3_SECRET_ACCESS_KEY || "";
+  const clientConfig = { region };
+  if (accessKeyId && secretAccessKey) {
+    clientConfig.credentials = {
+      accessKeyId,
+      secretAccessKey
+    };
+  }
+  s3Client = new S3Client(clientConfig);
+  return s3Client;
+}
+async function streamToString(stream) {
+  const chunks = [];
+  for await (const chunk of stream) {
+    chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+  }
+  return Buffer.concat(chunks).toString("utf-8");
+}
+async function request(config = {}, endpoint, options = {}) {
+  await loadAWSSDK();
+  const client = await getClient(config);
+  const bucket = config.S3_BUCKET || "";
+  const TENANT = config.S3_TENANT || "";
+  let key = "";
+  if (options.filetype && options.filetype == true) {
+    key = TENANT + "/" + endpoint;
+  } else {
+    key = TENANT + "/" + endpoint + ".json";
+  }
+  const command = new GetObjectCommand({ Bucket: bucket, Key: key });
+  try {
+    const start = Date.now();
+    const response = await client.send(command);
+    const body = await streamToString(response.Body);
+    const fetchTimeMs = Date.now() - start;
+    const fixed = body;
+    if (response.ContentType == "application/json") {
+      const parsed = JSON.parse(fixed);
+      parsed.fetchTimeMs = fetchTimeMs;
+      return parsed;
+    } else {
+      return fixed;
+    }
+  } catch (error) {
+    throw error;
+  }
+}
+export const flowrixS3 = {
+  get: (endpoint, config = {}, options = {}) => request(config, endpoint, options)
+};

package/dist/runtime/pages/404.d.vue.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/pages/404.vue

@@ -0,0 +1,6 @@
+<script setup lang="ts">
+
+</script>
+<template>
+Default 404 page
+</template>

package/dist/runtime/pages/404.vue.d.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/pages/flowrix-default.d.vue.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/pages/flowrix-default.vue

@@ -0,0 +1,112 @@
+<script setup>
+import { useRoute } from "vue-router";
+import { defineAsyncComponent, computed } from "vue";
+import { setResponseStatus, setHeader } from "h3";
+import { useRequestEvent } from "#app";
+const event = useRequestEvent();
+import { usePromotions } from "../stores/promotions";
+const DynamicContent = defineAsyncComponent(() => import("../components/Types/dynamic.vue"));
+const Category = defineAsyncComponent(() => import("@/components/Category/index.vue"));
+const Product = defineAsyncComponent(() => import("@/components/Product/index.vue"));
+const BlogSingle = defineAsyncComponent(() => import("@/components/blog/single.vue"));
+const PageComponent = defineAsyncComponent(() => import("@/components/pages/index.vue"));
+const cmsCategory = defineAsyncComponent(() => import("@/components/cmscategory/index.vue"));
+const Brand = defineAsyncComponent(() => import("@/components/Brand/index.vue"));
+const route = useRoute();
+const slug = route.params.slug || "home";
+const { data, error } = await useFetch(`/api/permalink/${slug}`, {
+  server: true,
+  lazy: false
+});
+if (import.meta.server && error.value) {
+  const statusCode = error.value.statusCode || 500;
+  setResponseStatus(event, statusCode);
+  setHeader(
+    event,
+    "Cache-Control",
+    "public, max-age=0, s-maxage=0, must-revalidate"
+  );
+}
+const redirectPage = (async (redirectData) => {
+  return navigateTo(`/${redirectData.target}`, { redirectCode: redirectData.status_code || 404 });
+});
+if (data.value?.permalink?.type === "redirect") {
+  redirectPage(data.value?.permalink);
+}
+useHead({
+  style: [
+    {
+      innerHTML: data.value?.permalink?.content?.css || "",
+      type: "text/css"
+    }
+  ]
+});
+const DynamicComponent = computed(() => {
+  const type = data.value?.permalink?.type;
+  if (!type || type === "redirect") {
+    return null;
+  }
+  return defineAsyncComponent(
+    () => import(`@/components/Types/${type}/index.vue`).catch(
+      () => import(`../components/Types/${type}/index.vue`)
+    ).catch(
+      () => import("./404.vue")
+    )
+  );
+});
+const NotFoundComponent = defineAsyncComponent(async () => {
+  const project404 = import.meta.glob("~/components/404.vue");
+  const projectKey = "/components/404.vue";
+  if (projectKey && project404[projectKey]) {
+    return project404[projectKey]();
+  }
+  try {
+    const module404 = await import("./404.vue");
+    return module404.default;
+  } catch (e) {
+    return {
+      template: `<div>Default 404 Page</div>`
+    };
+  }
+});
+</script>
+
+<template>
+  <template v-if="data && data.permalink.is_dynamic == true">
+  <template v-if="data && DynamicComponent">
+    <component :is="DynamicComponent" :data="data.data" />
+  </template>
+  <template v-else>   
+      <NotFoundComponent/>
+  </template>
+  </template><!-- end is dynamic true-->
+  <template v-else>
+   <template v-if="data && data?.permalink.type == 'product'">
+            <Product :product="data" />
+        </template>
+        <template v-if="data && data?.permalink.type == 'page'">       
+            <PageComponent v-if="data" :pageData="data?.data" />
+        </template>
+        <template v-if="data && data?.permalink.type == 'brand'">
+            <Brand v-if="data" :data="data?.data" />
+        </template>
+        <template v-if="data && data?.permalink.type == 'category'">
+            <Category :data="data?.data"/>
+        </template>
+        <template v-if="data && data?.permalink.type == 'post'">
+            <div class="container-fluid px-xl-5 px-0">
+                <BlogSingle :data="data?.data" />
+            </div>
+        </template>
+        <template v-if="data && data?.permalink.type == 'cmscategory'">
+            <div class="container-fluid px-xl-5 px-4">
+                <cmsCategory :data="data?.data" />
+            </div>
+        </template>
+  </template>
+  <component v-if="error" :is="NotFoundComponent"/>
+</template>
+
+<style>
+body,html{margin:0;padding:0}
+</style>

package/dist/runtime/pages/flowrix-default.vue.d.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/plugin.d.ts

@@ -1,2 +1,2 @@
-declare const _default: import("#app").Plugin<Record<string, unknown>> & import("#app").ObjectPlugin<Record<string, unknown>>;
+declare const _default: any;
 export default _default;

package/dist/runtime/plugins/bootstrap.client.d.ts

@@ -0,0 +1,3 @@
+import 'bootstrap/dist/js/bootstrap.bundle.min.js';
+declare const _default: any;
+export default _default;

package/dist/runtime/plugins/bootstrap.client.js

@@ -0,0 +1,4 @@
+import { defineNuxtPlugin } from "#app";
+import "bootstrap/dist/js/bootstrap.bundle.min.js";
+export default defineNuxtPlugin(() => {
+});

package/dist/runtime/plugins/full-reload.client.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/plugins/full-reload.client.js

@@ -0,0 +1,28 @@
+export default defineNuxtPlugin((nuxtApp) => {
+  const router = useRouter();
+  let isFirstLoad = true;
+  router.beforeEach((to, from) => {
+    if (to.path == from.path) {
+      isFirstLoad = false;
+    } else {
+      if (isFirstLoad) {
+        isFirstLoad = false;
+        return;
+      }
+      console.log(isFirstLoad);
+      if (to.query.customize) {
+        return;
+      }
+      const url = new URL(to.fullPath, window.location.origin);
+      const authToken = useCookie("authToken").value;
+      const customerType = useCookie("customertype").value;
+      console.log(url.href, window.location.origin + "/");
+      console.log(authToken && customerType && Number(customerType) > 1 && url.href !== window.location.origin + "/");
+      if (authToken && customerType && Number(customerType) > 1 && url.href !== window.location.origin + "/") {
+        url.searchParams.set("type", customerType);
+      }
+      window.location.href = url.pathname + url.search;
+      return false;
+    }
+  });
+});

package/dist/runtime/plugins/router.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/plugins/router.js

@@ -0,0 +1,11 @@
+import { defineNuxtPlugin } from "#app";
+export default defineNuxtPlugin((nuxtApp) => {
+  const router = nuxtApp.$router;
+  if (!router.hasRoute("default")) {
+    router.addRoute({
+      name: "default",
+      path: "/:slug(.*)",
+      component: () => import("../pages/flowrix-default.vue")
+    });
+  }
+});

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

@@ -1,18 +1,19 @@
-import { defineEventHandler, setResponseStatus } from "h3";
-import { $fetch } from "ofetch";
+import { defineEventHandler } from "h3";
+import { useRuntimeConfig } from "#imports";
+import { flowrixS3 } from "../../middleware/flowrixs3.js";
 export default defineEventHandler(async (event) => {
+  const config = useRuntimeConfig();
+  const endpoint = "albums";
   try {
-    const albums = await $fetch(`${process.env.FLOWRIX_API_BASE}albums`, {
-      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 albums;
-  } catch (error) {
-    setResponseStatus(event, 500);
-    return { success: false, error: error.message };
+    const s3Data = await flowrixS3.get(endpoint, config);
+    console.log("Loaded from S3:", endpoint);
+    return s3Data;
+  } catch (s3Error) {
+    console.log("S3 fetch failed:", s3Error.message);
+    return {
+      status: "Error",
+      message: "File not found",
+      error: s3Error.message
+    };
   }
 });

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

@@ -1,11 +0,0 @@
-interface AuthUser {
-    id: string | number;
-    email: string;
-    firstName?: string;
-    lastName?: string;
-}
-declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<{
-    user: AuthUser;
-    token: string;
-}>>;
-export default _default;

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

@@ -1,69 +0,0 @@
-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/banners.d.ts

@@ -1,3 +1,2 @@
-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

@@ -1,41 +1,19 @@
-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);
-  }
-}
+import { defineEventHandler } from "h3";
+import { useRuntimeConfig } from "#imports";
+import { flowrixS3 } from "../../middleware/flowrixs3.js";
 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) {
-  }
+  const config = useRuntimeConfig();
+  const endpoint = "banners/index";
   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
-    });
+    const s3Data = await flowrixS3.get(endpoint, config);
+    console.log("Loaded from S3:", endpoint);
+    return s3Data;
+  } catch (s3Error) {
+    console.log("S3 fetch failed:", s3Error.message);
+    return {
+      status: "Error",
+      message: "File not found",
+      error: s3Error.message
+    };
   }
 });

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

@@ -0,0 +1,26 @@
+import { defineEventHandler, getQuery, createError } from "h3";
+import { flowrixS3 } from "../../../middleware/flowrixs3.js";
+import { useRuntimeConfig } from "#imports";
+export default defineEventHandler(async (event) => {
+  const slug = event.context.params?._;
+  const config = useRuntimeConfig();
+  let query = getQuery(event);
+  if (!slug) {
+    throw createError({ statusCode: 400, statusMessage: "Missing slug parameter" });
+  }
+  if (!/^[a-zA-Z0-9-_]+$/.test(slug)) {
+  }
+  const endpoint = `brands/${slug}`;
+  try {
+    const s3Data = await flowrixS3.get(endpoint, config);
+    console.log("Loaded from S3:", endpoint);
+    return s3Data;
+  } catch (s3Error) {
+    console.log("S3 fetch failed:", s3Error.message);
+    return {
+      status: "Error",
+      message: "File not found",
+      error: s3Error.message
+    };
+  }
+});

package/dist/runtime/server/api/brand/index.js

@@ -0,0 +1,20 @@
+import { defineEventHandler, getQuery } from "h3";
+import { useRuntimeConfig } from "#imports";
+import { flowrixS3 } from "../../../middleware/flowrixs3.js";
+export default defineEventHandler(async (event) => {
+  const config = useRuntimeConfig();
+  let query = getQuery(event);
+  const endpoint = "brands";
+  try {
+    const s3Data = await flowrixS3.get(endpoint, config);
+    console.log("Loaded from S3:", endpoint);
+    return s3Data;
+  } catch (s3Error) {
+    console.log("S3 fetch failed:", s3Error.message);
+    return {
+      status: "Error",
+      message: "File not found",
+      error: s3Error.message
+    };
+  }
+});

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

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

package/dist/runtime/server/api/cache/[...slug].delete.js

@@ -1,8 +1,8 @@
-import { defineEventHandler, getQuery, createError } from "h3";
+import { defineEventHandler, getQuery } from "h3";
 import { join } from "path";
 import fs from "fs";
 import path from "path";
-const CACHE_DIR = join(process.cwd(), ".nuxt", "cache");
+const CACHE_DIR = join("/tmp", ".cache");
 export default defineEventHandler(async (event) => {
   const slug = event.context.params._;
   try {
@@ -31,10 +31,6 @@ export default defineEventHandler(async (event) => {
     }
     return deletedFiles;
   } catch (error) {
-    throw createError({
-      statusCode: 500,
-      statusMessage: `Cache not clear for slug: ${slug}`,
-      data: error.message
-    });
+    return { success: false, error: error.message };
   }
 });

package/dist/runtime/server/api/cache/clean.get.d.ts

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

package/dist/runtime/server/api/cache/clean.get.js

@@ -1,16 +1,12 @@
-import { defineEventHandler, createError } from "h3";
+import { defineEventHandler } from "h3";
 import { join } from "path";
 import { rm } from "fs/promises";
-const CACHE_DIR = join(process.cwd(), ".nuxt", "cache");
+const CACHE_DIR = join("/tmp", ".cache");
 export default defineEventHandler(async (event) => {
   try {
     await rm(CACHE_DIR, { recursive: true, force: true });
     return { success: true, message: "Cache deleted successfully" };
   } catch (error) {
-    throw createError({
-      statusCode: 500,
-      statusMessage: `Cache not cleared`,
-      data: error.message
-    });
+    return { success: false, error: error.message };
   }
 });

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

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

package/dist/runtime/server/api/cart/[slug]/add.js

@@ -1,21 +0,0 @@
-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

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

package/dist/runtime/server/api/cart/[slug]/update.js

@@ -1,21 +0,0 @@
-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

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

package/dist/runtime/server/api/cart/remove.js

@@ -1,21 +0,0 @@
-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 };
-  }
-});