@enfyra/sdk-nuxt 0.3.19 → 0.3.20

package/src/{composables → runtime/composables}/useEnfyraApi.ts

@@ -6,7 +6,7 @@ import type {
   UseEnfyraApiSSRReturn,
   UseEnfyraApiClientReturn,
   BatchProgress,
-} from "../types";
+} from "../../types";
 import { $fetch } from "../utils/http";
 import { getAppUrl, normalizeUrl } from "../utils/url";
 import { ENFYRA_API_PREFIX } from "../constants/config";
@@ -68,13 +68,13 @@ export function useEnfyraApi<T = any>(
     const clientHeaders = process.client
       ? {}
       : useRequestHeaders([
-          "authorization",
-          "cookie",
-          "user-agent",
-          "accept",
-          "accept-language",
-          "referer",
-        ]);
+        "authorization",
+        "cookie",
+        "user-agent",
+        "accept",
+        "accept-language",
+        "referer",
+      ]);
 
     const serverHeaders = { ...clientHeaders };
     delete serverHeaders.connection;
@@ -83,7 +83,7 @@ export function useEnfyraApi<T = any>(
     delete serverHeaders["content-length"];
 
     const nuxtApp = useNuxtApp()
-    
+
     const fetchOptions: any = {
       method: method as any,
       body: body,
@@ -141,7 +141,7 @@ export function useEnfyraApi<T = any>(
     }
 
     const result = useFetch<T>(finalUrl, fetchOptions);
-    
+
     // Map pending to loading for better naming
     // useFetch returns AsyncData with 'pending', but UseEnfyraApiSSRReturn uses 'loading'
     return {
@@ -207,13 +207,13 @@ export function useEnfyraApi<T = any>(
 
         const chunks = effectiveBatchSize
           ? Array.from(
-              { length: Math.ceil(items.length / effectiveBatchSize) },
-              (_, i) =>
-                items.slice(
-                  i * effectiveBatchSize,
-                  i * effectiveBatchSize + effectiveBatchSize
-                )
-            )
+            { length: Math.ceil(items.length / effectiveBatchSize) },
+            (_, i) =>
+              items.slice(
+                i * effectiveBatchSize,
+                i * effectiveBatchSize + effectiveBatchSize
+              )
+          )
           : [items];
 
         const totalBatches = chunks.length;

package/src/{composables → runtime/composables}/useEnfyraAuth.ts

@@ -1,5 +1,5 @@
 import { ref, computed } from "vue";
-import type { LoginPayload, User, UseEnfyraAuthReturn } from "../types/auth";
+import type { LoginPayload, User, UseEnfyraAuthReturn } from "../../types/auth";
 import { useEnfyraApi } from "./useEnfyraApi";
 
 const me = ref<User | null>(null);
@@ -33,7 +33,7 @@ export function useEnfyraAuth() {
 
     try {
       const queryParams: any = {};
-      
+
       if (options?.fields && options.fields.length > 0) {
         queryParams.fields = options.fields.join(",");
       }

package/src/runtime/server/api/all.ts

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

package/src/runtime/server/api/login.post.ts

@@ -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";
+import { normalizeUrl } from "../../utils/url";
 
 export default defineEventHandler(async (event) => {
   const config = useRuntimeConfig();

package/src/runtime/server/api/logout.post.ts

@@ -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";
+import { normalizeUrl } from "../../utils/url";
 
 export default defineEventHandler(async (event) => {
   const config = useRuntimeConfig();

package/src/runtime/server/middleware/auth.ts

@@ -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";
+import { REFRESH_TOKEN_KEY } from "../../constants/auth";
 
 export default defineEventHandler(async (event) => {
   if (

package/src/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/src/{utils → runtime/utils}/server/proxy.ts

@@ -1,7 +1,7 @@
 import { H3Event, proxyRequest } from "h3";
 import { useRuntimeConfig } from "#imports";
 import { ENFYRA_API_PREFIX } from "../../constants/config";
-import { normalizeUrl } from "../../utils/url";
+import { normalizeUrl } from "../url";
 
 export function proxyToAPI(event: H3Event, customPath?: string) {
   const config = useRuntimeConfig();

package/src/{utils → runtime/utils}/server/refreshToken.ts

@@ -5,7 +5,7 @@ import {
   REFRESH_TOKEN_KEY,
   EXP_TIME_KEY,
 } from "../../constants/auth";
-import { normalizeUrl } from "../../utils/url";
+import { normalizeUrl } from "../url";
 
 interface TokenValidationResult {
   accessToken: string | null;
@@ -18,7 +18,7 @@ export function decodeJWT(token: string): any {
     if (parts.length !== 3) {
       return null;
     }
-    
+
     // Decode the payload (second part)
     const payload = parts[1];
     const decodedPayload = Buffer.from(payload, "base64url").toString("utf-8");
@@ -34,7 +34,7 @@ export function isAccessTokenExpired(accessToken: string): boolean {
   if (!decoded || !decoded.exp) {
     return true;
   }
-  
+
   // JWT exp is in seconds, Date.now() is in milliseconds
   const expirationTime = decoded.exp * 1000;
   return Date.now() >= expirationTime;

package/dist/composables/useEnfyraApi.d.ts

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

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

@@ -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,
-    };
-}