@enfyra/sdk-nuxt 0.3.18 → 0.3.20

package/dist/runtime/composables/useEnfyraApi.js

@@ -0,0 +1,345 @@
+import { ref, unref, toRaw } from "vue";
+import { $fetch } from "../utils/http.js";
+import { getAppUrl, normalizeUrl } from "../utils/url.js";
+import { ENFYRA_API_PREFIX } from "../constants/config.js";
+import { useRuntimeConfig, useFetch, useRequestHeaders, useNuxtApp } from "#imports";
+function handleError(error, context, customHandler) {
+  const apiError = {
+    message: error?.message || error?.data?.message || "Request failed",
+    status: error?.status || error?.response?.status,
+    data: error?.data || error?.response?.data,
+    response: error?.response || error
+  };
+  if (customHandler) {
+    customHandler(apiError, context);
+  } else {
+    console.error(`[Enfyra API Error]`, { error: apiError, context });
+  }
+  return apiError;
+}
+export function useEnfyraApi(path, opts = {}) {
+  const { method = "get", body, query, errorContext, onError, ssr, key } = opts;
+  const batchOptions = opts;
+  const { batchSize, concurrent, onProgress } = batchOptions;
+  if (ssr) {
+    const config = useRuntimeConfig().public.enfyraSDK;
+    const basePath = (typeof path === "function" ? path() : path).replace(/^\/?api\/?/, "").replace(/^\/+/, "");
+    const appUrl = getAppUrl();
+    const finalUrl = normalizeUrl(
+      appUrl,
+      config?.apiPrefix || ENFYRA_API_PREFIX,
+      basePath
+    );
+    const clientHeaders = process.client ? {} : useRequestHeaders([
+      "authorization",
+      "cookie",
+      "user-agent",
+      "accept",
+      "accept-language",
+      "referer"
+    ]);
+    const serverHeaders = { ...clientHeaders };
+    delete serverHeaders.connection;
+    delete serverHeaders["keep-alive"];
+    delete serverHeaders.host;
+    delete serverHeaders["content-length"];
+    const nuxtApp = useNuxtApp();
+    const fetchOptions = {
+      method,
+      body,
+      query,
+      headers: {
+        ...serverHeaders,
+        ...opts.headers
+      }
+    };
+    if (key !== void 0) {
+      fetchOptions.key = key;
+    }
+    if (opts.default !== void 0) {
+      fetchOptions.default = opts.default;
+    }
+    if (opts.server !== void 0) {
+      fetchOptions.server = opts.server;
+    }
+    if (opts.lazy !== void 0) {
+      fetchOptions.lazy = opts.lazy;
+    }
+    if (opts.immediate !== void 0) {
+      fetchOptions.immediate = opts.immediate;
+    }
+    if (opts.transform !== void 0) {
+      fetchOptions.transform = opts.transform;
+    }
+    if (opts.pick !== void 0) {
+      fetchOptions.pick = opts.pick;
+    }
+    if (opts.watch !== void 0) {
+      fetchOptions.watch = opts.watch;
+    }
+    if (opts.deep !== void 0) {
+      fetchOptions.deep = opts.deep;
+    }
+    if (opts.getCachedData !== void 0) {
+      fetchOptions.getCachedData = opts.getCachedData;
+    } else {
+      fetchOptions.getCachedData = (cacheKey) => {
+        return nuxtApp.payload.data[cacheKey] || nuxtApp.static.data[cacheKey];
+      };
+    }
+    if (opts.refresh !== void 0) {
+      fetchOptions.refresh = opts.refresh;
+    }
+    if (opts.refreshInterval !== void 0) {
+      fetchOptions.refreshInterval = opts.refreshInterval;
+    }
+    if (opts.dedupe !== void 0) {
+      fetchOptions.dedupe = opts.dedupe;
+    }
+    const result = useFetch(finalUrl, fetchOptions);
+    return {
+      ...result,
+      loading: result.pending,
+      pending: result.pending
+      // Keep for backward compatibility
+    };
+  }
+  const data = ref(null);
+  const error = ref(null);
+  const pending = ref(false);
+  const execute = async (executeOpts) => {
+    pending.value = true;
+    error.value = null;
+    try {
+      const config = useRuntimeConfig().public.enfyraSDK;
+      const apiUrl = getAppUrl();
+      const apiPrefix = config?.apiPrefix;
+      const basePath = (typeof path === "function" ? path() : path).replace(/^\/?api\/?/, "").replace(/^\/+/, "");
+      const finalBody = executeOpts?.body || unref(body);
+      const finalQuery = executeOpts?.query || unref(query);
+      const isBatchOperation = !opts.disableBatch && (executeOpts?.ids && executeOpts.ids.length > 0 && (method.toLowerCase() === "patch" || method.toLowerCase() === "delete") || method.toLowerCase() === "post" && executeOpts?.files && Array.isArray(executeOpts.files) && executeOpts.files.length > 0);
+      const effectiveBatchSize = isBatchOperation ? executeOpts?.batchSize ?? batchSize : void 0;
+      const effectiveConcurrent = isBatchOperation ? executeOpts?.concurrent ?? concurrent : void 0;
+      const effectiveOnProgress = isBatchOperation ? executeOpts?.onProgress ?? onProgress : void 0;
+      const buildPath = (...segments) => {
+        return segments.filter(Boolean).join("/");
+      };
+      const fullBaseURL = normalizeUrl(apiUrl, apiPrefix || ENFYRA_API_PREFIX);
+      async function processBatch(items, processor) {
+        const results = [];
+        const progressResults = [];
+        const startTime = Date.now();
+        let completed = 0;
+        let failed = 0;
+        const chunks = effectiveBatchSize ? Array.from(
+          { length: Math.ceil(items.length / effectiveBatchSize) },
+          (_, i) => items.slice(
+            i * effectiveBatchSize,
+            i * effectiveBatchSize + effectiveBatchSize
+          )
+        ) : [items];
+        const totalBatches = chunks.length;
+        let currentBatch = 0;
+        const updateProgress = (inProgress = 0) => {
+          if (effectiveOnProgress) {
+            const elapsed = Date.now() - startTime;
+            const progress = items.length > 0 ? Math.round(completed / items.length * 100) : 0;
+            const averageTime = completed > 0 ? elapsed / completed : void 0;
+            const operationsPerSecond = completed > 0 ? completed / elapsed * 1e3 : void 0;
+            const estimatedTimeRemaining = averageTime && items.length > completed ? Math.round(averageTime * (items.length - completed)) : void 0;
+            const progressData = {
+              progress,
+              completed,
+              total: items.length,
+              failed,
+              inProgress,
+              estimatedTimeRemaining,
+              averageTime,
+              currentBatch: currentBatch + 1,
+              totalBatches,
+              operationsPerSecond,
+              results: [...progressResults]
+            };
+            effectiveOnProgress(progressData);
+          }
+        };
+        updateProgress(0);
+        if (!effectiveBatchSize && !effectiveConcurrent) {
+          updateProgress(items.length);
+          const promises = items.map(async (item, index) => {
+            const itemStartTime = Date.now();
+            try {
+              const result = await processor(item, index);
+              const duration = Date.now() - itemStartTime;
+              completed++;
+              progressResults.push({
+                index,
+                status: "completed",
+                result,
+                duration
+              });
+              updateProgress(items.length - completed);
+              return result;
+            } catch (error2) {
+              const duration = Date.now() - itemStartTime;
+              failed++;
+              completed++;
+              progressResults.push({
+                index,
+                status: "failed",
+                error: error2,
+                duration
+              });
+              updateProgress(items.length - completed);
+              throw error2;
+            }
+          });
+          const results2 = await Promise.all(promises);
+          updateProgress(0);
+          return results2;
+        }
+        for (let chunkIndex = 0; chunkIndex < chunks.length; chunkIndex++) {
+          currentBatch = chunkIndex;
+          const chunk = chunks[chunkIndex];
+          if (effectiveConcurrent && chunk.length > effectiveConcurrent) {
+            for (let i = 0; i < chunk.length; i += effectiveConcurrent) {
+              const batch = chunk.slice(i, i + effectiveConcurrent);
+              const baseIndex = chunkIndex * (effectiveBatchSize || items.length) + i;
+              updateProgress(batch.length);
+              const batchPromises = batch.map(async (item, batchItemIndex) => {
+                const globalIndex = baseIndex + batchItemIndex;
+                const itemStartTime = Date.now();
+                try {
+                  const result = await processor(item, globalIndex);
+                  const duration = Date.now() - itemStartTime;
+                  completed++;
+                  progressResults.push({
+                    index: globalIndex,
+                    status: "completed",
+                    result,
+                    duration
+                  });
+                  updateProgress(
+                    Math.max(0, batch.length - (batchItemIndex + 1))
+                  );
+                  return result;
+                } catch (error2) {
+                  const duration = Date.now() - itemStartTime;
+                  failed++;
+                  completed++;
+                  progressResults.push({
+                    index: globalIndex,
+                    status: "failed",
+                    error: error2,
+                    duration
+                  });
+                  updateProgress(
+                    Math.max(0, batch.length - (batchItemIndex + 1))
+                  );
+                  throw error2;
+                }
+              });
+              const batchResults = await Promise.all(batchPromises);
+              results.push(...batchResults);
+            }
+          } else {
+            const baseIndex = chunkIndex * (effectiveBatchSize || items.length);
+            updateProgress(chunk.length);
+            const chunkPromises = chunk.map(async (item, chunkItemIndex) => {
+              const globalIndex = baseIndex + chunkItemIndex;
+              const itemStartTime = Date.now();
+              try {
+                const result = await processor(item, globalIndex);
+                const duration = Date.now() - itemStartTime;
+                completed++;
+                progressResults.push({
+                  index: globalIndex,
+                  status: "completed",
+                  result,
+                  duration
+                });
+                updateProgress(
+                  Math.max(0, chunk.length - (chunkItemIndex + 1))
+                );
+                return result;
+              } catch (error2) {
+                const duration = Date.now() - itemStartTime;
+                failed++;
+                completed++;
+                progressResults.push({
+                  index: globalIndex,
+                  status: "failed",
+                  error: error2,
+                  duration
+                });
+                updateProgress(
+                  Math.max(0, chunk.length - (chunkItemIndex + 1))
+                );
+                throw error2;
+              }
+            });
+            const chunkResults = await Promise.all(chunkPromises);
+            results.push(...chunkResults);
+          }
+        }
+        updateProgress(0);
+        return results;
+      }
+      if (isBatchOperation && executeOpts?.ids && executeOpts.ids.length > 0) {
+        const responses = await processBatch(
+          executeOpts.ids,
+          async (id) => {
+            const finalPath2 = buildPath(basePath, id);
+            return $fetch(finalPath2, {
+              baseURL: fullBaseURL,
+              method,
+              body: finalBody ? toRaw(finalBody) : void 0,
+              headers: opts.headers,
+              query: finalQuery
+            });
+          }
+        );
+        data.value = responses;
+        return responses;
+      }
+      if (isBatchOperation && executeOpts?.files && Array.isArray(executeOpts.files) && executeOpts.files.length > 0) {
+        const responses = await processBatch(
+          executeOpts.files,
+          async (fileObj) => {
+            return $fetch(basePath, {
+              baseURL: fullBaseURL,
+              method,
+              body: fileObj,
+              headers: opts.headers,
+              query: finalQuery
+            });
+          }
+        );
+        data.value = responses;
+        return responses;
+      }
+      const finalPath = executeOpts?.id ? buildPath(basePath, executeOpts.id) : basePath;
+      const response = await $fetch(finalPath, {
+        baseURL: fullBaseURL,
+        method,
+        body: finalBody ? toRaw(finalBody) : void 0,
+        headers: opts.headers,
+        query: finalQuery
+      });
+      data.value = response;
+      return response;
+    } catch (err) {
+      const apiError = handleError(err, errorContext, onError);
+      error.value = apiError;
+      return null;
+    } finally {
+      pending.value = false;
+    }
+  };
+  return {
+    data,
+    error,
+    pending,
+    execute
+  };
+}

package/dist/runtime/composables/useEnfyraAuth.js

@@ -0,0 +1,81 @@
+import { ref, computed } from "vue";
+import { useEnfyraApi } from "./useEnfyraApi.js";
+const me = ref(null);
+const isLoading = ref(false);
+export function useEnfyraAuth() {
+  const {
+    data: loginData,
+    execute: executeLogin,
+    error: loginError
+  } = useEnfyraApi("/login", {
+    method: "post",
+    errorContext: "Login"
+  });
+  const { execute: executeLogout } = useEnfyraApi("/logout", {
+    method: "post",
+    errorContext: "Logout"
+  });
+  const {
+    data: meData,
+    execute: executeFetchUser,
+    error: fetchUserError
+  } = useEnfyraApi("/me", {
+    errorContext: "Fetch User Profile"
+  });
+  const fetchUser = async (options) => {
+    isLoading.value = true;
+    try {
+      const queryParams = {};
+      if (options?.fields && options.fields.length > 0) {
+        queryParams.fields = options.fields.join(",");
+      }
+      await executeFetchUser({
+        query: queryParams
+      });
+      if (fetchUserError.value) {
+        me.value = null;
+        return;
+      }
+      me.value = meData.value?.data?.[0];
+    } finally {
+      isLoading.value = false;
+    }
+  };
+  const login = async (payload) => {
+    isLoading.value = true;
+    try {
+      await executeLogin({ body: payload });
+      if (loginError.value) {
+        return null;
+      }
+      return loginData.value;
+    } finally {
+      isLoading.value = false;
+    }
+  };
+  const logout = async () => {
+    isLoading.value = true;
+    try {
+      await executeLogout();
+      me.value = null;
+      if (typeof window !== "undefined") {
+        window.location.reload();
+      }
+    } catch (error) {
+      me.value = null;
+      if (typeof window !== "undefined") {
+        window.location.reload();
+      }
+    } finally {
+      isLoading.value = false;
+    }
+  };
+  const isLoggedIn = computed(() => !!me.value);
+  return {
+    me,
+    login,
+    logout,
+    fetchUser,
+    isLoggedIn
+  };
+}

package/dist/runtime/constants/auth.js

@@ -0,0 +1,3 @@
+export const ACCESS_TOKEN_KEY = "accessToken";
+export const REFRESH_TOKEN_KEY = "refreshToken";
+export const EXP_TIME_KEY = "expTime";

package/dist/runtime/constants/config.js

@@ -0,0 +1 @@
+export const ENFYRA_API_PREFIX = "/enfyra/api";

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

@@ -1,5 +1,5 @@
 import { defineEventHandler } from "h3";
-import { proxyToAPI } from "../../../utils/server/proxy";
+import { proxyToAPI } from "../../utils/server/proxy.js";
 export default defineEventHandler(async (event) => {
   return proxyToAPI(event);
 });

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

@@ -12,8 +12,8 @@ import {
   ACCESS_TOKEN_KEY,
   REFRESH_TOKEN_KEY,
   EXP_TIME_KEY
-} from "../../../constants/auth";
-import { normalizeUrl } from "../../../utils/url";
+} from "../../constants/auth.js";
+import { normalizeUrl } from "../../utils/url.js";
 export default defineEventHandler(async (event) => {
   const config = useRuntimeConfig();
   const apiUrl = config.public.enfyraSDK?.apiUrl;

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

@@ -5,8 +5,8 @@ import {
   ACCESS_TOKEN_KEY,
   REFRESH_TOKEN_KEY,
   EXP_TIME_KEY
-} from "../../../constants/auth";
-import { normalizeUrl } from "../../../utils/url";
+} from "../../constants/auth.js";
+import { normalizeUrl } from "../../utils/url.js";
 export default defineEventHandler(async (event) => {
   const config = useRuntimeConfig();
   const apiUrl = config.public?.enfyraSDK?.apiUrl;

package/dist/runtime/server/middleware/auth.js

@@ -3,8 +3,8 @@ import { useRuntimeConfig } from "#imports";
 import {
   validateTokens,
   refreshAccessToken
-} from "../../../utils/server/refreshToken";
-import { REFRESH_TOKEN_KEY } from "../../../constants/auth";
+} from "../../utils/server/refreshToken.js";
+import { REFRESH_TOKEN_KEY } from "../../constants/auth.js";
 export default defineEventHandler(async (event) => {
   if (event.node.req.url === "/api/login" || event.node.req.url === "/api/logout") {
     return;

package/dist/runtime/shims.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Type shims for Nuxt auto-imports used in module runtime.
+ * These types are provided by Nuxt at runtime but need declarations for TypeScript.
+ */
+
+declare module "#imports" {
+    // Nuxt composables
+    export const useRuntimeConfig: () => {
+        public: {
+            enfyraSDK?: {
+                apiUrl?: string;
+                apiPrefix?: string;
+                configError?: boolean;
+                configErrorMessage?: string;
+            };
+        };
+        [key: string]: any;
+    };
+
+    export const useRequestHeaders: (
+        headers?: string[]
+    ) => Record<string, string | undefined>;
+
+    export const useRequestURL: () => URL;
+
+    export const useFetch: <T = any>(
+        url: string | (() => string),
+        options?: any
+    ) => any;
+
+    export const useNuxtApp: () => {
+        payload: {
+            data: Record<string, any>;
+            [key: string]: any;
+        };
+        static: {
+            data: Record<string, any>;
+            [key: string]: any;
+        };
+        [key: string]: any;
+    };
+
+    // Nuxt plugin
+    export const defineNuxtPlugin: (plugin: any) => any;
+
+    // Server utilities (from nitro)
+    export const defineCachedEventHandler: (
+        handler: any,
+        options?: any
+    ) => any;
+    export const getCookie: (
+        event: any,
+        name: string
+    ) => string | undefined;
+    export const setCookie: (
+        event: any,
+        name: string,
+        value: string,
+        options?: any
+    ) => void;
+    export const deleteCookie: (
+        event: any,
+        name: string,
+        options?: any
+    ) => void;
+    export const createError: (options: {
+        statusCode?: number;
+        statusMessage?: string;
+        message?: string;
+        data?: any;
+    }) => Error;
+}

package/dist/runtime/utils/http.js

@@ -0,0 +1,61 @@
+export async function $fetch(path, options = {}) {
+  const {
+    method = "GET",
+    body,
+    headers: optionHeaders = {},
+    query = {},
+    baseURL
+  } = options;
+  if (!baseURL) {
+    throw new Error("baseURL is required for $fetch");
+  }
+  const url = new URL(
+    path.startsWith("/") ? path.slice(1) : path,
+    baseURL.endsWith("/") ? baseURL : `${baseURL}/`
+  );
+  Object.entries(query).forEach(([key, value]) => {
+    if (value !== void 0 && value !== null) {
+      if (typeof value === "object") {
+        url.searchParams.append(key, JSON.stringify(value));
+      } else {
+        url.searchParams.append(key, String(value));
+      }
+    }
+  });
+  const headers = {
+    "Content-Type": "application/json",
+    ...optionHeaders
+  };
+  const fetchOptions = {
+    method: method.toUpperCase(),
+    headers
+  };
+  if (body && method.toUpperCase() !== "GET") {
+    if (body instanceof FormData) {
+      delete headers["Content-Type"];
+      fetchOptions.body = body;
+    } else {
+      fetchOptions.body = JSON.stringify(body);
+    }
+  }
+  try {
+    const response = await fetch(url.toString(), fetchOptions);
+    if (!response.ok) {
+      let errorData;
+      try {
+        errorData = await response.json();
+      } catch {
+        errorData = { message: response.statusText };
+      }
+      throw { response: { data: errorData } };
+    }
+    const contentType = response.headers.get("content-type");
+    if (contentType?.includes("application/json")) {
+      return await response.json();
+    } else {
+      return await response.text();
+    }
+  } catch (error) {
+    throw error;
+  }
+}

package/dist/runtime/utils/server/proxy.js

@@ -0,0 +1,14 @@
+import { proxyRequest } from "h3";
+import { useRuntimeConfig } from "#imports";
+import { ENFYRA_API_PREFIX } from "../../constants/config.js";
+import { normalizeUrl } from "../url.js";
+export function proxyToAPI(event, customPath) {
+  const config = useRuntimeConfig();
+  const apiPrefix = config.public?.enfyraSDK?.apiPrefix || ENFYRA_API_PREFIX;
+  const rawPath = customPath || event.path.replace(new RegExp(`^${apiPrefix}`), "");
+  const targetUrl = normalizeUrl(config.public?.enfyraSDK?.apiUrl, rawPath);
+  const headers = event.context.proxyHeaders || {};
+  return proxyRequest(event, targetUrl, {
+    headers
+  });
+}