@enfyra/sdk-nuxt 0.3.17 → 0.3.19

package/dist/composables/useEnfyraApi.d.ts

@@ -0,0 +1,8 @@
+import type { ApiOptions, UseEnfyraApiSSRReturn, UseEnfyraApiClientReturn } from "../types";
+export declare function useEnfyraApi<T = any>(path: (() => string) | string, opts: ApiOptions<T> & {
+    ssr: true;
+}): UseEnfyraApiSSRReturn<T>;
+export declare function useEnfyraApi<T = any>(path: (() => string) | string, opts?: ApiOptions<T> & {
+    ssr?: false | undefined;
+}): UseEnfyraApiClientReturn<T>;
+//# sourceMappingURL=useEnfyraApi.d.ts.map

package/dist/composables/useEnfyraApi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useEnfyraApi.d.ts","sourceRoot":"","sources":["../../src/composables/useEnfyraApi.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,UAAU,EAGV,qBAAqB,EACrB,wBAAwB,EAEzB,MAAM,UAAU,CAAC;AA4BlB,wBAAgB,YAAY,CAAC,CAAC,GAAG,GAAG,EAClC,IAAI,EAAE,CAAC,MAAM,MAAM,CAAC,GAAG,MAAM,EAC7B,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG;IAAE,GAAG,EAAE,IAAI,CAAA;CAAE,GAClC,qBAAqB,CAAC,CAAC,CAAC,CAAC;AAE5B,wBAAgB,YAAY,CAAC,CAAC,GAAG,GAAG,EAClC,IAAI,EAAE,CAAC,MAAM,MAAM,CAAC,GAAG,MAAM,EAC7B,IAAI,CAAC,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG;IAAE,GAAG,CAAC,EAAE,KAAK,GAAG,SAAS,CAAA;CAAE,GACjD,wBAAwB,CAAC,CAAC,CAAC,CAAC"}

package/dist/composables/useEnfyraApi.js

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