@enfyra/sdk-nuxt 0.3.19 → 0.3.21

package/dist/composables/useEnfyraApi.js

@@ -1,363 +0,0 @@
-import { ref, unref, toRaw } from "vue";
-import { $fetch } from "../utils/http";
-import { getAppUrl, normalizeUrl } from "../utils/url";
-import { ENFYRA_API_PREFIX } from "../constants/config";
-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: method,
-            body: body,
-            query: query,
-            headers: {
-                ...serverHeaders,
-                ...opts.headers,
-            },
-        };
-        // Pass all useFetch-specific options
-        if (key !== undefined) {
-            fetchOptions.key = key;
-        }
-        if (opts.default !== undefined) {
-            fetchOptions.default = opts.default;
-        }
-        if (opts.server !== undefined) {
-            fetchOptions.server = opts.server;
-        }
-        if (opts.lazy !== undefined) {
-            fetchOptions.lazy = opts.lazy;
-        }
-        if (opts.immediate !== undefined) {
-            fetchOptions.immediate = opts.immediate;
-        }
-        if (opts.transform !== undefined) {
-            fetchOptions.transform = opts.transform;
-        }
-        if (opts.pick !== undefined) {
-            fetchOptions.pick = opts.pick;
-        }
-        if (opts.watch !== undefined) {
-            fetchOptions.watch = opts.watch;
-        }
-        if (opts.deep !== undefined) {
-            fetchOptions.deep = opts.deep;
-        }
-        if (opts.getCachedData !== undefined) {
-            fetchOptions.getCachedData = opts.getCachedData;
-        }
-        else {
-            // Auto-add getCachedData to ensure cache is used in SPA navigation
-            fetchOptions.getCachedData = (cacheKey) => {
-                return nuxtApp.payload.data[cacheKey] || nuxtApp.static.data[cacheKey];
-            };
-        }
-        if (opts.refresh !== undefined) {
-            fetchOptions.refresh = opts.refresh;
-        }
-        if (opts.refreshInterval !== undefined) {
-            fetchOptions.refreshInterval = opts.refreshInterval;
-        }
-        if (opts.dedupe !== undefined) {
-            fetchOptions.dedupe = opts.dedupe;
-        }
-        const result = useFetch(finalUrl, fetchOptions);
-        // Map pending to loading for better naming
-        // useFetch returns AsyncData with 'pending', but UseEnfyraApiSSRReturn uses 'loading'
-        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
-                : undefined;
-            const effectiveConcurrent = isBatchOperation
-                ? executeOpts?.concurrent ?? concurrent
-                : undefined;
-            const effectiveOnProgress = isBatchOperation
-                ? executeOpts?.onProgress ?? onProgress
-                : undefined;
-            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 : undefined;
-                        const operationsPerSecond = completed > 0 ? (completed / elapsed) * 1000 : undefined;
-                        const estimatedTimeRemaining = averageTime && items.length > completed
-                            ? Math.round(averageTime * (items.length - completed))
-                            : undefined;
-                        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 (error) {
-                            const duration = Date.now() - itemStartTime;
-                            failed++;
-                            completed++;
-                            progressResults.push({
-                                index,
-                                status: "failed",
-                                error: error,
-                                duration,
-                            });
-                            updateProgress(items.length - completed);
-                            throw error;
-                        }
-                    });
-                    const results = await Promise.all(promises);
-                    updateProgress(0);
-                    return results;
-                }
-                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 (error) {
-                                    const duration = Date.now() - itemStartTime;
-                                    failed++;
-                                    completed++;
-                                    progressResults.push({
-                                        index: globalIndex,
-                                        status: "failed",
-                                        error: error,
-                                        duration,
-                                    });
-                                    updateProgress(Math.max(0, batch.length - (batchItemIndex + 1)));
-                                    throw error;
-                                }
-                            });
-                            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 (error) {
-                                const duration = Date.now() - itemStartTime;
-                                failed++;
-                                completed++;
-                                progressResults.push({
-                                    index: globalIndex,
-                                    status: "failed",
-                                    error: error,
-                                    duration,
-                                });
-                                updateProgress(Math.max(0, chunk.length - (chunkItemIndex + 1)));
-                                throw error;
-                            }
-                        });
-                        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 finalPath = buildPath(basePath, id);
-                    return $fetch(finalPath, {
-                        baseURL: fullBaseURL,
-                        method: method,
-                        body: finalBody ? toRaw(finalBody) : undefined,
-                        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: 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: method,
-                body: finalBody ? toRaw(finalBody) : undefined,
-                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/composables/useEnfyraAuth.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"useEnfyraAuth.d.ts","sourceRoot":"","sources":["../../src/composables/useEnfyraAuth.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,IAAI,EAAuB,MAAM,eAAe,CAAC;AAM7E,wBAAgB,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAgDG,YAAY;;mCAzBP;QAAE,MAAM,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE;;EAqEzD"}

package/dist/composables/useEnfyraAuth.js

@@ -1,77 +0,0 @@
-import { ref, computed } from "vue";
-import { useEnfyraApi } from "./useEnfyraApi";
-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/constants/config.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/constants/config.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,iBAAiB,gBAAgB,CAAC"}

package/dist/constants/config.mjs

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

package/dist/runtime/plugin/config-error.client.mjs

@@ -1,107 +0,0 @@
-import { defineNuxtPlugin, useRuntimeConfig } from "#imports";
-export default defineNuxtPlugin(() => {
-  const config = useRuntimeConfig().public?.enfyraSDK;
-  if (config?.configError) {
-    if (typeof window !== "undefined" && document) {
-      let showError = function() {
-        const errorDiv = document.createElement("div");
-        errorDiv.id = "enfyra-config-error";
-        errorDiv.style.cssText = `
-          position: fixed;
-          top: 0;
-          left: 0;
-          right: 0;
-          bottom: 0;
-          background: rgba(0, 0, 0, 0.9);
-          display: flex;
-          align-items: center;
-          justify-content: center;
-          z-index: 999999;
-          font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Helvetica Neue', Arial, sans-serif;
-        `;
-        const content = document.createElement("div");
-        content.style.cssText = `
-          background: white;
-          padding: 40px;
-          border-radius: 12px;
-          max-width: 600px;
-          width: 90%;
-          box-shadow: 0 20px 60px rgba(0, 0, 0, 0.3);
-        `;
-        content.innerHTML = `
-          <div style="display: flex; align-items: center; margin-bottom: 20px;">
-            <svg width="32" height="32" viewBox="0 0 24 24" fill="none" style="margin-right: 12px;">
-              <circle cx="12" cy="12" r="10" stroke="#ef4444" stroke-width="2"/>
-              <path d="M12 8v4M12 16h.01" stroke="#ef4444" stroke-width="2" stroke-linecap="round"/>
-            </svg>
-            <h1 style="margin: 0; color: #1f2937; font-size: 24px; font-weight: 600;">
-              Configuration Error
-            </h1>
-          </div>
-          
-          <div style="color: #4b5563; margin-bottom: 24px; line-height: 1.6;">
-            <p style="margin: 0 0 16px 0; font-size: 16px;">
-              <strong>Enfyra SDK</strong> is not configured properly.
-            </p>
-            <p style="margin: 0; color: #6b7280; font-size: 14px;">
-              ${config?.configErrorMessage || "Missing required configuration"}
-            </p>
-          </div>
-          
-          <div style="background: #f9fafb; border: 1px solid #e5e7eb; border-radius: 8px; padding: 16px; margin-bottom: 24px;">
-            <p style="margin: 0 0 12px 0; color: #6b7280; font-size: 13px; text-transform: uppercase; letter-spacing: 0.5px;">
-              Add to your nuxt.config.ts:
-            </p>
-            <pre style="margin: 0; background: #1f2937; color: #f3f4f6; padding: 16px; border-radius: 6px; overflow-x: auto; font-size: 14px; line-height: 1.4;"><code>export default defineNuxtConfig({
-  modules: ["@enfyra/sdk-nuxt"],
-  enfyraSDK: {
-    <span style="color: #fbbf24;">apiUrl</span>: <span style="color: #34d399;">"https://your-api-url"</span>
-  }
-})</code></pre>
-          </div>
-          
-          <div style="display: flex; gap: 12px;">
-            <button onclick="location.reload()" style="
-              background: #3b82f6;
-              color: white;
-              border: none;
-              padding: 10px 20px;
-              border-radius: 6px;
-              font-size: 14px;
-              font-weight: 500;
-              cursor: pointer;
-              transition: background 0.2s;
-            " onmouseover="this.style.background='#2563eb'" onmouseout="this.style.background='#3b82f6'">
-              Reload Page
-            </button>
-            <button onclick="document.getElementById('enfyra-config-error').style.display='none'" style="
-              background: #f3f4f6;
-              color: #4b5563;
-              border: 1px solid #e5e7eb;
-              padding: 10px 20px;
-              border-radius: 6px;
-              font-size: 14px;
-              font-weight: 500;
-              cursor: pointer;
-              transition: all 0.2s;
-            " onmouseover="this.style.background='#e5e7eb'" onmouseout="this.style.background='#f3f4f6'">
-              Dismiss
-            </button>
-          </div>
-        `;
-        errorDiv.appendChild(content);
-        document.body.appendChild(errorDiv);
-        console.error(
-          "%c\u26A0\uFE0F Enfyra SDK Configuration Error",
-          "color: #ef4444; font-size: 16px; font-weight: bold;",
-          "\n\n" + (config?.configErrorMessage || "Missing required configuration") + '\n\nPlease add the following to your nuxt.config.ts:\n\nenfyraSDK: {\n  apiUrl: "https://your-api-url"\n}'
-        );
-      };
-      if (document.readyState === "loading") {
-        document.addEventListener("DOMContentLoaded", showError);
-      } else {
-        showError();
-      }
-    }
-  }
-});

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

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

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

@@ -1,62 +0,0 @@
-import {
-  defineEventHandler,
-  readBody,
-  setCookie,
-  createError,
-  sendError,
-  getHeader
-} from "h3";
-import { useRuntimeConfig } from "#imports";
-import { $fetch } from "ofetch";
-import {
-  ACCESS_TOKEN_KEY,
-  REFRESH_TOKEN_KEY,
-  EXP_TIME_KEY
-} from "../../../constants/auth";
-import { normalizeUrl } from "../../../utils/url";
-export default defineEventHandler(async (event) => {
-  const config = useRuntimeConfig();
-  const apiUrl = config.public.enfyraSDK?.apiUrl;
-  try {
-    const body = await readBody(event);
-    const response = await $fetch(normalizeUrl(apiUrl, "/auth/login"), {
-      method: "POST",
-      body,
-      headers: {
-        cookie: getHeader(event, "cookie") || ""
-      }
-    });
-    const { accessToken, refreshToken, expTime } = response;
-    const cookieOptions = {
-      httpOnly: true,
-      secure: true,
-      sameSite: "lax",
-      path: "/"
-    };
-    setCookie(event, ACCESS_TOKEN_KEY, accessToken, cookieOptions);
-    setCookie(event, REFRESH_TOKEN_KEY, refreshToken, cookieOptions);
-    setCookie(event, EXP_TIME_KEY, String(expTime), cookieOptions);
-    return { accessToken };
-  } catch (err) {
-    const statusCode = err?.response?.status || err?.statusCode || 401;
-    const errorData = err?.response?._data || err?.data;
-    let errorMessage = "Authentication failed";
-    let errorCode = "AUTHENTICATION_ERROR";
-    if (errorData?.error) {
-      errorMessage = errorData.error.message || errorData.message || errorMessage;
-      errorCode = errorData.error.code || errorCode;
-    }
-    return sendError(
-      event,
-      createError({
-        statusCode,
-        statusMessage: errorMessage,
-        data: {
-          code: errorCode,
-          details: errorData?.error?.details,
-          correlationId: errorData?.error?.correlationId
-        }
-      })
-    );
-  }
-});

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

@@ -1,35 +0,0 @@
-import { defineEventHandler, getHeader, getCookie, deleteCookie } from "h3";
-import { useRuntimeConfig } from "#imports";
-import { $fetch } from "ofetch";
-import {
-  ACCESS_TOKEN_KEY,
-  REFRESH_TOKEN_KEY,
-  EXP_TIME_KEY
-} from "../../../constants/auth";
-import { normalizeUrl } from "../../../utils/url";
-export default defineEventHandler(async (event) => {
-  const config = useRuntimeConfig();
-  const apiUrl = config.public?.enfyraSDK?.apiUrl;
-  const refreshToken = getCookie(event, REFRESH_TOKEN_KEY);
-  try {
-    const result = await $fetch(normalizeUrl(apiUrl, "/auth/logout"), {
-      method: "POST",
-      headers: {
-        cookie: getHeader(event, "cookie") || "",
-        authorization: event.context.proxyHeaders?.authorization
-      },
-      body: {
-        refreshToken
-      }
-    });
-    deleteCookie(event, ACCESS_TOKEN_KEY);
-    deleteCookie(event, REFRESH_TOKEN_KEY);
-    deleteCookie(event, EXP_TIME_KEY);
-    return result;
-  } catch (err) {
-    deleteCookie(event, ACCESS_TOKEN_KEY);
-    deleteCookie(event, REFRESH_TOKEN_KEY);
-    deleteCookie(event, EXP_TIME_KEY);
-    return { success: false, message: "Logout completed locally" };
-  }
-});