@enfyra/sdk-nuxt 0.3.18 → 0.3.20

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

@@ -0,0 +1,69 @@
+import { setCookie, getCookie, deleteCookie } from "h3";
+import { $fetch } from "ofetch";
+import {
+  ACCESS_TOKEN_KEY,
+  REFRESH_TOKEN_KEY,
+  EXP_TIME_KEY
+} from "../../constants/auth.js";
+import { normalizeUrl } from "../url.js";
+export function decodeJWT(token) {
+  try {
+    const parts = token.split(".");
+    if (parts.length !== 3) {
+      return null;
+    }
+    const payload = parts[1];
+    const decodedPayload = Buffer.from(payload, "base64url").toString("utf-8");
+    return JSON.parse(decodedPayload);
+  } catch (error) {
+    console.warn("Failed to decode JWT:", error);
+    return null;
+  }
+}
+export function isAccessTokenExpired(accessToken) {
+  const decoded = decodeJWT(accessToken);
+  if (!decoded || !decoded.exp) {
+    return true;
+  }
+  const expirationTime = decoded.exp * 1e3;
+  return Date.now() >= expirationTime;
+}
+export function validateTokens(event) {
+  const accessToken = getCookie(event, ACCESS_TOKEN_KEY);
+  const refreshToken = getCookie(event, REFRESH_TOKEN_KEY);
+  if (accessToken && !isAccessTokenExpired(accessToken)) {
+    return { accessToken, needsRefresh: false };
+  } else if (refreshToken && (!accessToken || isAccessTokenExpired(accessToken))) {
+    return { accessToken: null, needsRefresh: true };
+  }
+  return { accessToken: null, needsRefresh: false };
+}
+export async function refreshAccessToken(event, refreshToken, apiUrl) {
+  try {
+    const response = await $fetch(normalizeUrl(apiUrl, "/auth/refresh-token"), {
+      method: "POST",
+      body: { refreshToken }
+    });
+    const {
+      accessToken: newAccessToken,
+      refreshToken: newRefreshToken,
+      expTime: newExpTime
+    } = response;
+    const cookieOptions = {
+      httpOnly: true,
+      secure: true,
+      sameSite: "lax",
+      path: "/"
+    };
+    setCookie(event, ACCESS_TOKEN_KEY, newAccessToken, cookieOptions);
+    setCookie(event, REFRESH_TOKEN_KEY, newRefreshToken, cookieOptions);
+    setCookie(event, EXP_TIME_KEY, String(newExpTime), cookieOptions);
+    return newAccessToken;
+  } catch (error) {
+    console.warn("Token refresh failed:", error);
+    deleteCookie(event, ACCESS_TOKEN_KEY);
+    deleteCookie(event, REFRESH_TOKEN_KEY);
+    deleteCookie(event, EXP_TIME_KEY);
+    throw error;
+  }
+}

package/dist/runtime/utils/url.js

@@ -0,0 +1,56 @@
+export function normalizeUrl(...segments) {
+  const validSegments = segments.filter((s) => Boolean(s));
+  if (validSegments.length === 0) return "";
+  let result = validSegments[0].replace(/\/+$/, "");
+  for (let i = 1; i < validSegments.length; i++) {
+    const segment = validSegments[i].replace(/^\/+/, "").replace(/\/+$/, "").replace(/\/+/g, "/");
+    if (segment) {
+      result += "/" + segment;
+    }
+  }
+  return result;
+}
+export function joinUrlPath(...paths) {
+  const validPaths = paths.filter((p) => Boolean(p));
+  if (validPaths.length === 0) return "";
+  return validPaths.map((path) => path.replace(/^\/+/, "").replace(/\/+$/, "")).filter(Boolean).join("/");
+}
+export function getAppUrl() {
+  if (process.client && typeof window !== "undefined") {
+    return window.location.origin;
+  }
+  if (process.server) {
+    try {
+      let useRequestHeaders;
+      let useRequestURL;
+      try {
+        const imports = eval('require("#imports")');
+        useRequestHeaders = imports.useRequestHeaders;
+        useRequestURL = imports.useRequestURL;
+      } catch (e) {
+        return "";
+      }
+      try {
+        const url = useRequestURL();
+        if (url) {
+          return `${url.protocol}//${url.host}`;
+        }
+      } catch (e) {
+      }
+      const headers = useRequestHeaders();
+      const forwarded = headers["x-forwarded-host"] || headers["x-forwarded-server"];
+      const protocol = headers["x-forwarded-proto"] || "https";
+      if (forwarded) {
+        return `${protocol}://${forwarded}`;
+      }
+      const host = headers.host;
+      if (host) {
+        const isHttps = protocol === "https" || headers["x-forwarded-ssl"] === "on";
+        return `${isHttps ? "https" : "http"}://${host}`;
+      }
+    } catch (e) {
+      console.warn("[Enfyra SDK] Could not auto-detect app URL on server:", e);
+    }
+  }
+  return "";
+}

package/dist/types.d.mts

@@ -0,0 +1,7 @@
+import type { NuxtModule } from '@nuxt/schema'
+
+import type { default as Module } from './module.js'
+
+export type ModuleOptions = typeof Module extends NuxtModule<infer O> ? Partial<O> : Record<string, any>
+
+export { default } from './module.js'

package/dist/types.d.ts

@@ -0,0 +1,7 @@
+import type { NuxtModule } from '@nuxt/schema'
+
+import type { default as Module } from './module'
+
+export type ModuleOptions = typeof Module extends NuxtModule<infer O> ? Partial<O> : Record<string, any>
+
+export { default } from './module'

package/index.ts

@@ -1,3 +1,3 @@
-export * from './module'
+export * from './src/module'
 export * from './src/types'
 

package/module.d.ts

@@ -1,14 +1,24 @@
-import type { ModuleOptions } from './module'
+import type { ModuleOptions } from "./src/module";
 
-declare module '@nuxt/schema' {
+declare module "@nuxt/schema" {
   interface NuxtConfig {
-    enfyraSDK?: ModuleOptions
+    enfyraSDK?: ModuleOptions;
   }
   interface NuxtOptions {
-    enfyraSDK?: ModuleOptions
+    enfyraSDK?: ModuleOptions;
+  }
+  interface PublicRuntimeConfig {
+    enfyraSDK?: ModuleOptions & {
+      configError?: boolean;
+      configErrorMessage?: string;
+    };
   }
 }
 
-export type { ModuleOptions } from './module'
-export type * from './src/types'
+declare module "#imports" {
+  export const useEnfyraApi: typeof import("./src/runtime/composables/useEnfyraApi").useEnfyraApi;
+  export const useEnfyraAuth: typeof import("./src/runtime/composables/useEnfyraAuth").useEnfyraAuth;
+}
 
+export type { ModuleOptions } from "./src/module";
+export type * from "./src/types";

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "@enfyra/sdk-nuxt",
-  "version": "0.3.18",
+  "version": "0.3.20",
+  "type": "module",
   "description": "Nuxt SDK for Enfyra CMS",
   "repository": {
     "type": "git",
@@ -10,40 +11,28 @@
     "url": "https://github.com/dothinh115/enfyra-sdk-nuxt/issues"
   },
   "homepage": "https://github.com/dothinh115/enfyra-sdk-nuxt#readme",
-  "main": "./module.ts",
-  "types": "./module.d.ts",
+  "main": "./dist/module.mjs",
+  "types": "./dist/types.d.ts",
   "exports": {
     ".": {
-      "types": "./module.d.ts",
-      "import": "./module.ts"
+      "import": "./dist/module.mjs",
+      "require": "./dist/module.cjs",
+      "types": "./dist/types.d.ts"
     },
-    "./src/composables/useEnfyraApi": {
-      "types": "./src/composables/useEnfyraApi.ts",
-      "import": "./src/composables/useEnfyraApi.ts"
+    "./runtime/*": {
+      "types": "./dist/runtime/*.d.ts",
+      "import": "./dist/runtime/*.js"
     },
-    "./src/composables/useEnfyraAuth": {
-      "types": "./src/composables/useEnfyraAuth.ts",
-      "import": "./src/composables/useEnfyraAuth.ts"
-    },
-    "./src/types": {
-      "types": "./src/types/index.ts",
-      "import": "./src/types/index.ts"
-    },
-    "./src/runtime/server/api/all": "./src/runtime/server/api/all.ts",
-    "./src/runtime/server/api/all.ts": "./src/runtime/server/api/all.ts",
-    "./src/runtime/server/api/login.post": "./src/runtime/server/api/login.post.ts",
-    "./src/runtime/server/api/login.post.ts": "./src/runtime/server/api/login.post.ts",
-    "./src/runtime/server/api/logout.post": "./src/runtime/server/api/logout.post.ts",
-    "./src/runtime/server/api/logout.post.ts": "./src/runtime/server/api/logout.post.ts",
-    "./src/runtime/server/middleware/auth": "./src/runtime/server/middleware/auth.ts",
-    "./src/runtime/server/middleware/auth.ts": "./src/runtime/server/middleware/auth.ts"
+    "./types": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
   },
   "files": [
-    "module.ts",
+    "dist/",
+    "src/",
     "module.d.ts",
-    "index.ts",
-    "src/**/*",
-    "dist/runtime/**/*"
+    "index.ts"
   ],
   "keywords": [
     "nuxt",
@@ -57,21 +46,30 @@
     "access": "public"
   },
   "scripts": {
-    "build": "unbuild && npx tsc --noEmit --skipLibCheck",
-    "prepublishOnly": "unbuild"
+    "dev": "nuxi dev playground",
+    "build": "nuxt-module-build build && npx tsc -p tsconfig.build.json",
+    "prepack": "nuxt-module-build build && npx tsc -p tsconfig.build.json",
+    "test": "vitest",
+    "test:ui": "vitest --ui",
+    "test:run": "vitest run"
   },
   "peerDependencies": {
     "@nuxt/kit": "^3.18.1",
     "vue": "^3.0.0"
   },
   "dependencies": {
+    "defu": "^6.1.4",
     "h3": "^1.15.4",
     "ofetch": "^1.3.3"
   },
   "devDependencies": {
+    "@nuxt/module-builder": "^0.8.4",
     "@types/node": "^24.10.1",
+    "@vitest/ui": "^3.2.4",
     "nuxt": "^3.18.1",
     "typescript": "^5.0.0",
-    "unbuild": "^2.0.0"
+    "vite": "^6.0.7",
+    "vite-plugin-dts": "^4.3.0",
+    "vitest": "^3.2.4"
   }
-}
+}

package/src/module.ts

@@ -0,0 +1,129 @@
+import {
+  defineNuxtModule,
+  createResolver,
+  addServerHandler,
+  addImports,
+  addPlugin,
+  useLogger,
+} from "@nuxt/kit";
+import { defu } from "defu";
+import { ENFYRA_API_PREFIX } from "./runtime/constants/config";
+
+export interface ModuleOptions {
+  apiUrl: string;
+  apiPrefix?: string;
+}
+
+export default defineNuxtModule<ModuleOptions>({
+  meta: {
+    name: "@enfyra/sdk-nuxt",
+    configKey: "enfyraSDK",
+    compatibility: {
+      nuxt: ">=3.0.0",
+    },
+  },
+  defaults: {
+    apiUrl: "",
+    apiPrefix: ENFYRA_API_PREFIX,
+  },
+  setup(options, nuxt) {
+    const logger = useLogger("enfyra-sdk");
+    const { resolve } = createResolver(import.meta.url);
+
+    const normalizedOptions = {
+      ...options,
+      apiUrl:
+        typeof options.apiUrl === "string"
+          ? options.apiUrl.replace(/\/+$/, "")
+          : options.apiUrl,
+      apiPrefix:
+        typeof options.apiPrefix === "string"
+          ? options.apiPrefix.trim()
+            ? "/" +
+            options.apiPrefix
+              .replace(/^\/+|\/+$/g, "")
+              .replace(/\/+/g, "/")
+            : ENFYRA_API_PREFIX
+          : ENFYRA_API_PREFIX,
+    };
+
+    const apiPrefix = normalizedOptions.apiPrefix;
+
+    if (!normalizedOptions.apiUrl) {
+      logger.warn(
+        `Missing required configuration:\n` +
+        `- apiUrl is required\n` +
+        `Please configure it in your nuxt.config.ts:\n` +
+        `enfyraSDK: {\n` +
+        `  apiUrl: 'https://your-api-url'\n` +
+        `}`
+      );
+
+      nuxt.options.runtimeConfig.public.enfyraSDK = defu(
+        nuxt.options.runtimeConfig.public.enfyraSDK || {},
+        {
+          ...normalizedOptions,
+          apiPrefix: apiPrefix,
+          configError: true,
+          configErrorMessage:
+            "Enfyra SDK: apiUrl is required. Please configure it in nuxt.config.ts",
+        }
+      );
+    } else {
+      nuxt.options.runtimeConfig.public.enfyraSDK = defu(
+        nuxt.options.runtimeConfig.public.enfyraSDK || {},
+        {
+          ...normalizedOptions,
+          apiPrefix: apiPrefix,
+        }
+      );
+    }
+
+    if (!normalizedOptions.apiUrl) {
+      addPlugin({
+        src: resolve("./runtime/plugin/config-error.client"),
+        mode: "client",
+      });
+    }
+
+    // Register composables for auto-import with explicit declarations
+    addImports([
+      {
+        name: "useEnfyraApi",
+        from: resolve("./runtime/composables/useEnfyraApi"),
+      },
+      {
+        name: "useEnfyraAuth",
+        from: resolve("./runtime/composables/useEnfyraAuth"),
+      },
+    ]);
+
+    // Server handlers
+    addServerHandler({
+      handler: resolve("./runtime/server/middleware/auth"),
+      middleware: true,
+    });
+
+    addServerHandler({
+      route: `${apiPrefix}/login`,
+      handler: resolve("./runtime/server/api/login.post"),
+      method: "post",
+    });
+
+    addServerHandler({
+      route: `${apiPrefix}/logout`,
+      handler: resolve("./runtime/server/api/logout.post"),
+      method: "post",
+    });
+
+    addServerHandler({
+      route: "/assets/**",
+      handler: resolve("./runtime/server/api/all"),
+    });
+
+    addServerHandler({
+      route: `${apiPrefix}/**`,
+      handler: resolve("./runtime/server/api/all"),
+    });
+  },
+});

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