mailsentry-auth 0.1.0

package/dist/utils/cookie-utils.js

@@ -0,0 +1,225 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }// src/services/utils/cookie-utils.ts
+var _jscookie = require('js-cookie'); var _jscookie2 = _interopRequireDefault(_jscookie);
+var _CookieUtils = class _CookieUtils {
+  /**
+   * Get the access token cookie key from environment variables
+   */
+  static getAccessTokenKey() {
+    return process.env.AUTH_ACCESS_TOKEN_KEY || "auth_access_token";
+  }
+  /**
+   * Get the refresh token cookie key from environment variables
+   */
+  static getRefreshTokenKey() {
+    return process.env.AUTH_REFRESH_TOKEN_KEY || "auth_refresh_token";
+  }
+  // Use current domain in development
+  /**
+   * Get root domain for subdomain support
+   */
+  static getRootDomain() {
+    if (typeof window === "undefined") return void 0;
+    const hostname = window.location.hostname;
+    if (hostname === "localhost" || hostname === "127.0.0.1") {
+      return void 0;
+    }
+    if (/^\d+\.\d+\.\d+\.\d+$/.test(hostname)) {
+      return void 0;
+    }
+    const parts = hostname.split(".");
+    if (parts.length >= 2) {
+      return `.${parts.slice(-2).join(".")}`;
+    }
+    return void 0;
+  }
+  /**
+   * Get common cookie options
+   */
+  static getCookieOptions() {
+    return {
+      path: "/",
+      sameSite: "strict",
+      secure: process.env.NODE_ENV === "production",
+      // Only secure in production
+      domain: this.COOKIE_DOMAIN
+      // Support subdomains
+    };
+  }
+  /**
+   * Check if running on client side
+   */
+  static isClientSide() {
+    return typeof window !== "undefined";
+  }
+  /**
+   * Check if running on server side
+   */
+  static isServerSide() {
+    return typeof window === "undefined";
+  }
+  /**
+   * Dynamically import server action for server-side operations
+   */
+  static async getServerTokens() {
+    try {
+      const { getAuthTokens } = await Promise.resolve().then(() => _interopRequireWildcard(require("mailsentry-auth/server")));
+      return await getAuthTokens();
+    } catch (error) {
+      console.error("Failed to get server tokens:", error);
+      return { accessToken: null, refreshToken: null };
+    }
+  }
+  /**
+   * Set access token in cookie (client-side only)
+   */
+  static setAccessToken(token) {
+    if (this.isServerSide()) {
+      console.warn("setAccessToken called on server side - use server actions instead");
+      return;
+    }
+    const options = this.getCookieOptions();
+    _jscookie2.default.set(this.getAccessTokenKey(), token, options);
+  }
+  /**
+   * Set refresh token in cookie (client-side only)
+   */
+  static setRefreshToken(token) {
+    if (this.isServerSide()) {
+      console.warn("setRefreshToken called on server side - use server actions instead");
+      return;
+    }
+    const options = this.getCookieOptions();
+    _jscookie2.default.set(this.getRefreshTokenKey(), token, options);
+  }
+  /**
+   * Get access token - automatically handles client/server side
+   */
+  static async getAccessToken() {
+    if (this.isClientSide()) {
+      return _jscookie2.default.get(this.getAccessTokenKey()) || null;
+    } else {
+      const { accessToken } = await this.getServerTokens();
+      return accessToken;
+    }
+  }
+  /**
+   * Get refresh token - automatically handles client/server side
+   */
+  static async getRefreshToken() {
+    if (this.isClientSide()) {
+      return _jscookie2.default.get(this.getRefreshTokenKey()) || null;
+    } else {
+      const { refreshToken } = await this.getServerTokens();
+      return refreshToken;
+    }
+  }
+  /**
+   * Get both tokens - automatically handles client/server side
+   */
+  static async getTokens() {
+    if (this.isClientSide()) {
+      return {
+        accessToken: _jscookie2.default.get(this.getAccessTokenKey()) || null,
+        refreshToken: _jscookie2.default.get(this.getRefreshTokenKey()) || null
+      };
+    } else {
+      return await this.getServerTokens();
+    }
+  }
+  /**
+   * Clear all authentication cookies (client-side only)
+   */
+  static clearAuthCookies() {
+    if (this.isServerSide()) {
+      console.warn("clearAuthCookies called on server side - use server actions instead");
+      return;
+    }
+    const removeOptions = {
+      path: "/",
+      domain: this.COOKIE_DOMAIN
+    };
+    _jscookie2.default.remove(this.getAccessTokenKey(), removeOptions);
+    _jscookie2.default.remove(this.getRefreshTokenKey(), removeOptions);
+  }
+  /**
+   * Check if cookies are supported/enabled (client-side only)
+   */
+  static areCookiesEnabled() {
+    if (this.isServerSide()) {
+      console.warn("areCookiesEnabled called on server side - not applicable");
+      return false;
+    }
+    try {
+      const testKey = "test_cookie_support";
+      const testOptions = this.getCookieOptions();
+      _jscookie2.default.set(testKey, "test", testOptions);
+      const value = _jscookie2.default.get(testKey);
+      _jscookie2.default.remove(testKey, {
+        path: "/",
+        domain: this.COOKIE_DOMAIN
+      });
+      return value === "test";
+    } catch (e) {
+      return false;
+    }
+  }
+  /**
+   * Get all authentication cookies - automatically handles client/server side
+   */
+  static async getAllAuthCookies() {
+    if (this.isClientSide()) {
+      return {
+        accessToken: _jscookie2.default.get(this.getAccessTokenKey()) || "",
+        refreshToken: _jscookie2.default.get(this.getRefreshTokenKey()) || ""
+      };
+    } else {
+      const { accessToken, refreshToken } = await this.getServerTokens();
+      return {
+        accessToken: accessToken || "",
+        refreshToken: refreshToken || ""
+      };
+    }
+  }
+  /**
+   * Set multiple tokens at once (client-side only)
+   */
+  static setTokens(accessToken, refreshToken) {
+    if (this.isServerSide()) {
+      console.warn("setTokens called on server side - use server actions instead");
+      return;
+    }
+    this.setAccessToken(accessToken);
+    this.setRefreshToken(refreshToken);
+  }
+  /**
+   * Check if user has valid tokens - automatically handles client/server side
+   */
+  static async hasValidTokens() {
+    const tokens = await this.getTokens();
+    return !!(tokens.accessToken && tokens.refreshToken);
+  }
+  /**
+   * Get current domain information for debugging
+   */
+  static getDomainInfo() {
+    if (this.isServerSide()) {
+      return {
+        error: "Server-side rendering - no domain info available",
+        environment: process.env.NODE_ENV || "unknown",
+        recommendation: "Use server actions for server-side cookie access"
+      };
+    }
+    return {
+      hostname: window.location.hostname,
+      domain: this.COOKIE_DOMAIN || "current domain",
+      environment: process.env.NODE_ENV || "unknown",
+      protocol: window.location.protocol
+    };
+  }
+};
+// Domain configuration
+_CookieUtils.COOKIE_DOMAIN = process.env.NODE_ENV === "production" ? _CookieUtils.getRootDomain() : void 0;
+var CookieUtils = _CookieUtils;
+
+
+exports.CookieUtils = CookieUtils;

package/dist/utils/cookie-utils.mjs

@@ -0,0 +1,225 @@
+// src/services/utils/cookie-utils.ts
+import Cookies from "js-cookie";
+var _CookieUtils = class _CookieUtils {
+  /**
+   * Get the access token cookie key from environment variables
+   */
+  static getAccessTokenKey() {
+    return process.env.AUTH_ACCESS_TOKEN_KEY || "auth_access_token";
+  }
+  /**
+   * Get the refresh token cookie key from environment variables
+   */
+  static getRefreshTokenKey() {
+    return process.env.AUTH_REFRESH_TOKEN_KEY || "auth_refresh_token";
+  }
+  // Use current domain in development
+  /**
+   * Get root domain for subdomain support
+   */
+  static getRootDomain() {
+    if (typeof window === "undefined") return void 0;
+    const hostname = window.location.hostname;
+    if (hostname === "localhost" || hostname === "127.0.0.1") {
+      return void 0;
+    }
+    if (/^\d+\.\d+\.\d+\.\d+$/.test(hostname)) {
+      return void 0;
+    }
+    const parts = hostname.split(".");
+    if (parts.length >= 2) {
+      return `.${parts.slice(-2).join(".")}`;
+    }
+    return void 0;
+  }
+  /**
+   * Get common cookie options
+   */
+  static getCookieOptions() {
+    return {
+      path: "/",
+      sameSite: "strict",
+      secure: process.env.NODE_ENV === "production",
+      // Only secure in production
+      domain: this.COOKIE_DOMAIN
+      // Support subdomains
+    };
+  }
+  /**
+   * Check if running on client side
+   */
+  static isClientSide() {
+    return typeof window !== "undefined";
+  }
+  /**
+   * Check if running on server side
+   */
+  static isServerSide() {
+    return typeof window === "undefined";
+  }
+  /**
+   * Dynamically import server action for server-side operations
+   */
+  static async getServerTokens() {
+    try {
+      const { getAuthTokens } = await import("mailsentry-auth/server");
+      return await getAuthTokens();
+    } catch (error) {
+      console.error("Failed to get server tokens:", error);
+      return { accessToken: null, refreshToken: null };
+    }
+  }
+  /**
+   * Set access token in cookie (client-side only)
+   */
+  static setAccessToken(token) {
+    if (this.isServerSide()) {
+      console.warn("setAccessToken called on server side - use server actions instead");
+      return;
+    }
+    const options = this.getCookieOptions();
+    Cookies.set(this.getAccessTokenKey(), token, options);
+  }
+  /**
+   * Set refresh token in cookie (client-side only)
+   */
+  static setRefreshToken(token) {
+    if (this.isServerSide()) {
+      console.warn("setRefreshToken called on server side - use server actions instead");
+      return;
+    }
+    const options = this.getCookieOptions();
+    Cookies.set(this.getRefreshTokenKey(), token, options);
+  }
+  /**
+   * Get access token - automatically handles client/server side
+   */
+  static async getAccessToken() {
+    if (this.isClientSide()) {
+      return Cookies.get(this.getAccessTokenKey()) || null;
+    } else {
+      const { accessToken } = await this.getServerTokens();
+      return accessToken;
+    }
+  }
+  /**
+   * Get refresh token - automatically handles client/server side
+   */
+  static async getRefreshToken() {
+    if (this.isClientSide()) {
+      return Cookies.get(this.getRefreshTokenKey()) || null;
+    } else {
+      const { refreshToken } = await this.getServerTokens();
+      return refreshToken;
+    }
+  }
+  /**
+   * Get both tokens - automatically handles client/server side
+   */
+  static async getTokens() {
+    if (this.isClientSide()) {
+      return {
+        accessToken: Cookies.get(this.getAccessTokenKey()) || null,
+        refreshToken: Cookies.get(this.getRefreshTokenKey()) || null
+      };
+    } else {
+      return await this.getServerTokens();
+    }
+  }
+  /**
+   * Clear all authentication cookies (client-side only)
+   */
+  static clearAuthCookies() {
+    if (this.isServerSide()) {
+      console.warn("clearAuthCookies called on server side - use server actions instead");
+      return;
+    }
+    const removeOptions = {
+      path: "/",
+      domain: this.COOKIE_DOMAIN
+    };
+    Cookies.remove(this.getAccessTokenKey(), removeOptions);
+    Cookies.remove(this.getRefreshTokenKey(), removeOptions);
+  }
+  /**
+   * Check if cookies are supported/enabled (client-side only)
+   */
+  static areCookiesEnabled() {
+    if (this.isServerSide()) {
+      console.warn("areCookiesEnabled called on server side - not applicable");
+      return false;
+    }
+    try {
+      const testKey = "test_cookie_support";
+      const testOptions = this.getCookieOptions();
+      Cookies.set(testKey, "test", testOptions);
+      const value = Cookies.get(testKey);
+      Cookies.remove(testKey, {
+        path: "/",
+        domain: this.COOKIE_DOMAIN
+      });
+      return value === "test";
+    } catch (e) {
+      return false;
+    }
+  }
+  /**
+   * Get all authentication cookies - automatically handles client/server side
+   */
+  static async getAllAuthCookies() {
+    if (this.isClientSide()) {
+      return {
+        accessToken: Cookies.get(this.getAccessTokenKey()) || "",
+        refreshToken: Cookies.get(this.getRefreshTokenKey()) || ""
+      };
+    } else {
+      const { accessToken, refreshToken } = await this.getServerTokens();
+      return {
+        accessToken: accessToken || "",
+        refreshToken: refreshToken || ""
+      };
+    }
+  }
+  /**
+   * Set multiple tokens at once (client-side only)
+   */
+  static setTokens(accessToken, refreshToken) {
+    if (this.isServerSide()) {
+      console.warn("setTokens called on server side - use server actions instead");
+      return;
+    }
+    this.setAccessToken(accessToken);
+    this.setRefreshToken(refreshToken);
+  }
+  /**
+   * Check if user has valid tokens - automatically handles client/server side
+   */
+  static async hasValidTokens() {
+    const tokens = await this.getTokens();
+    return !!(tokens.accessToken && tokens.refreshToken);
+  }
+  /**
+   * Get current domain information for debugging
+   */
+  static getDomainInfo() {
+    if (this.isServerSide()) {
+      return {
+        error: "Server-side rendering - no domain info available",
+        environment: process.env.NODE_ENV || "unknown",
+        recommendation: "Use server actions for server-side cookie access"
+      };
+    }
+    return {
+      hostname: window.location.hostname,
+      domain: this.COOKIE_DOMAIN || "current domain",
+      environment: process.env.NODE_ENV || "unknown",
+      protocol: window.location.protocol
+    };
+  }
+};
+// Domain configuration
+_CookieUtils.COOKIE_DOMAIN = process.env.NODE_ENV === "production" ? _CookieUtils.getRootDomain() : void 0;
+var CookieUtils = _CookieUtils;
+export {
+  CookieUtils
+};

package/package.json

@@ -0,0 +1,103 @@
+{
+  "name": "mailsentry-auth",
+  "version": "0.1.0",
+  "description": "Next.js 15 authentication package with multi-step auth flow, cross-tab sync, and Zustand state management",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    },
+    "./middleware": {
+      "types": "./dist/middleware.d.ts",
+      "import": "./dist/middleware.mjs"
+    },
+    "./server": {
+      "types": "./src/app/actions/index.ts",
+      "import": "./src/app/actions/index.ts",
+      "require": "./src/app/actions/index.ts"
+    },
+    "./utils": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/utils/cookie-utils.mjs"
+      },
+      "require": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/utils/cookie-utils.js"
+      }
+    }
+  },
+  "files": [
+    "dist",
+    "dist/utils",
+    "src/app/actions",
+    "README.md",
+    "ZUSTAND_MIGRATION.md"
+  ],
+  "scripts": {
+    "dev": "next dev --turbopack",
+    "build": "next build",
+    "build:package": "tsup",
+    "build:package:watch": "tsup --watch",
+    "build:link": "npm run build:package && npm link",
+    "link:sample": "cd ../nextjs-sample && npm link mailsentry-auth",
+    "build:link:sample": "npm run build:link && npm run link:sample",
+    "link:cutly": "cd ../cutly && pnpm link ../auth-nextjs",
+    "build:link:cutly": "pnpm run build:package && pnpm run link:cutly",
+    "start": "next start",
+    "lint": "next lint",
+    "format": "prettier --write \"src/**/*.{ts,tsx,js,jsx,json,css,scss}\"",
+    "prepublishOnly": "npm run build:package"
+  },
+  "peerDependencies": {
+    "next": ">=15.0.0",
+    "react": ">=18.0.0 || >=19.0.0",
+    "react-dom": ">=18.0.0 || >=19.0.0"
+  },
+  "dependencies": {
+    "@ant-design/icons": "^6.0.0",
+    "@types/js-cookie": "^3.0.6",
+    "antd": "^5.27.0",
+    "immer": "^10.1.1",
+    "js-cookie": "^3.0.5",
+    "zustand": "^5.0.8"
+  },
+  "devDependencies": {
+    "@eslint/eslintrc": "^3",
+    "@tailwindcss/postcss": "^4",
+    "@types/node": "^20",
+    "@types/react": "^19",
+    "@types/react-dom": "^19",
+    "eslint": "^9",
+    "eslint-config-next": "15.4.4",
+    "next": "15.4.4",
+    "prettier": "^3.6.2",
+    "react": "19.1.0",
+    "react-dom": "19.1.0",
+    "tailwindcss": "^4",
+    "tsup": "^8.5.1",
+    "typescript": "^5"
+  },
+  "keywords": [
+    "nextjs",
+    "authentication",
+    "auth",
+    "mailsentry",
+    "zustand",
+    "multi-step",
+    "cross-tab-sync",
+    "antd",
+    "typescript",
+    "react"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/danielaei/mailsentry-auth.git"
+  },
+  "author": "danielaei",
+  "license": "MIT"
+}

package/src/app/actions/auth-actions.ts

@@ -0,0 +1,22 @@
+'use server';
+
+import { cookies } from 'next/headers';
+
+/**
+ * Server action to get authentication tokens from cookies
+ * This function runs on the server side and can access cookies directly
+ * Returns tokens directly for easy use in cookie-utils
+ */
+export async function getAuthTokens(): Promise<{ accessToken: string | null; refreshToken: string | null }> {
+  try {
+    const cookieStore = await cookies();
+    
+    const accessToken = cookieStore.get('auth_access_token')?.value || null;
+    const refreshToken = cookieStore.get('auth_refresh_token')?.value || null;
+    
+    return { accessToken, refreshToken };
+  } catch (error) {
+    console.error('Error getting auth tokens from server:', error);
+    return { accessToken: null, refreshToken: null };
+  }
+}

package/src/app/actions/index.ts

@@ -0,0 +1,3 @@
+export { 
+  getAuthTokens,
+} from './auth-actions';