@vunexa/lixa 0.0.1-alpha.13 → 0.0.1-alpha.14

package/README.md

@@ -36,25 +36,25 @@ yarn add @vunexa/lixa
 ### 1. Configure lixa with multiple providers
 
 ```typescript
-import { Lixa } from '@vunexa/lixa';
+import { Lixa } from "@vunexa/lixa";
 
 const lixa = new Lixa({
   providers: {
     google: {
       clientId: process.env.GOOGLE_CLIENT_ID!,
       clientSecret: process.env.GOOGLE_CLIENT_SECRET!,
-      redirectUri: 'https://yourapp.com/auth/google/callback',
-      scopes: ['openid', 'email', 'profile'],
+      redirectUri: "https://yourapp.com/auth/google/callback",
+      scopes: ["openid", "email", "profile"],
       extraConfig: {
-        prompt: 'consent',
-        access_type: 'offline',
+        prompt: "consent",
+        access_type: "offline",
       },
     },
     github: {
       clientId: process.env.GITHUB_CLIENT_ID!,
       clientSecret: process.env.GITHUB_CLIENT_SECRET!,
-      redirectUri: 'https://yourapp.com/auth/github/callback',
-      scopes: ['read:user', 'user:email'],
+      redirectUri: "https://yourapp.com/auth/github/callback",
+      scopes: ["read:user", "user:email"],
       extraConfig: {},
     },
   },
@@ -64,10 +64,10 @@ const lixa = new Lixa({
     createSession: async (tokenData) => {
       // Custom session creation logic
       return {
-        token: 'custom-session-token',
-        raw: tokenData
+        token: "custom-session-token",
+        raw: tokenData,
       };
-    }
+    },
   },
 });
 ```
@@ -78,10 +78,10 @@ const lixa = new Lixa({
 app.get("/login", (req, res) => {
   const provider = req.query.provider as string; // 'google' or 'github'
   const state = lixa.generateRandomState();
-  
+
   // Store state in session for validation
   req.session.oauthState = state;
-  
+
   const authUrl = lixa.getAuthUrl(provider.toUpperCase(), state);
   res.redirect(authUrl);
 });
@@ -97,7 +97,7 @@ app.get("/auth/:provider/callback", async (req, res) => {
   try {
     // Validate state parameter
     if (state !== req.session.oauthState) {
-      throw new Error('Invalid state parameter');
+      throw new Error("Invalid state parameter");
     }
 
     const session = await lixa.handleCallback({
@@ -110,9 +110,9 @@ app.get("/auth/:provider/callback", async (req, res) => {
     res.cookie("session_token", session.token, {
       httpOnly: true,
       secure: true,
-      sameSite: 'strict'
+      sameSite: "strict",
     });
-    
+
     res.redirect("/dashboard");
   } catch (error) {
     console.error("Authentication error:", error);
@@ -128,29 +128,29 @@ app.get("/auth/:provider/callback", async (req, res) => {
 You can register custom OAuth providers by implementing the `IProvider` interface:
 
 ```typescript
-import { Lixa, IProvider } from '@vunexa/lixa';
+import { Lixa, IProvider } from "@vunexa/lixa";
 
 class CustomProvider implements IProvider {
-  authorizationEndpoint = 'https://custom-provider.com/oauth/authorize';
-  tokenEndpoint = 'https://custom-provider.com/oauth/token';
-  userInfoEndpoint = 'https://custom-provider.com/api/user';
+  authorizationEndpoint = "https://custom-provider.com/oauth/authorize";
+  tokenEndpoint = "https://custom-provider.com/oauth/token";
+  userInfoEndpoint = "https://custom-provider.com/api/user";
 }
 
 // Register the custom provider
 Lixa.registerProvider({
-  custom: new CustomProvider()
+  custom: new CustomProvider(),
 });
 
 // Use it in your configuration
 const lixa = new Lixa({
   providers: {
     custom: {
-      clientId: 'your-client-id',
-      clientSecret: 'your-client-secret',
-      redirectUri: 'https://yourapp.com/auth/custom/callback',
-      scopes: ['read:user'],
-    }
-  }
+      clientId: "your-client-id",
+      clientSecret: "your-client-secret",
+      redirectUri: "https://yourapp.com/auth/custom/callback",
+      scopes: ["read:user"],
+    },
+  },
 });
 ```
 
@@ -158,8 +158,8 @@ const lixa = new Lixa({
 
 ```typescript
 // Check if a provider is registered
-if (Lixa.isProviderRegistered('google')) {
-  console.log('Google provider is available');
+if (Lixa.isProviderRegistered("google")) {
+  console.log("Google provider is available");
 }
 ```
 
@@ -168,13 +168,16 @@ if (Lixa.isProviderRegistered('google')) {
 ### `Lixa` Class
 
 #### Constructor
+
 - `new Lixa(config: LixaConfig)` - Creates a new Lixa instance
 
 #### Static Methods
+
 - `Lixa.registerProvider(providerMap: { [key: string]: IProvider })` - Register custom providers
 - `Lixa.isProviderRegistered(provider: string): boolean` - Check if a provider is registered
 
 #### Instance Methods
+
 - `generateRandomState(): string` - Generate a random state parameter for OAuth flow
 - `getAuthUrl(provider: string, state: string): string` - Get authorization URL for a provider
 - `handleCallback({ provider, code, state }): Promise<Session>` - Handle OAuth callback and create session

package/dist/dao/session-cache.cjs

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalSessionCache = void 0;
+const node_cache_1 = __importDefault(require("node-cache"));
+class LocalSessionCache {
+    cache;
+    constructor(defaultTtlSeconds = 600) {
+        this.cache = new node_cache_1.default({ stdTTL: defaultTtlSeconds });
+    }
+    async saveSession(state, data, expiresInSeconds) {
+        this.cache.set(state, data, expiresInSeconds);
+    }
+    async getSession(state) {
+        return this.cache.get(state) || null;
+    }
+    async deleteSession(state) {
+        this.cache.del(state);
+    }
+}
+exports.LocalSessionCache = LocalSessionCache;
+//# sourceMappingURL=session-cache.js.map

package/dist/dao/state-cache.cjs

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalStateCache = void 0;
+const node_cache_1 = __importDefault(require("node-cache"));
+class LocalStateCache {
+    cache;
+    constructor(defaultTtlSeconds = 600) {
+        this.cache = new node_cache_1.default({ stdTTL: defaultTtlSeconds });
+    }
+    async saveState(state, data, expiresInSeconds) {
+        this.cache.set(state, data, expiresInSeconds);
+    }
+    async getState(state) {
+        return this.cache.get(state) || null;
+    }
+    async deleteState(state) {
+        this.cache.del(state);
+    }
+}
+exports.LocalStateCache = LocalStateCache;
+//# sourceMappingURL=state-cache.js.map

package/dist/dao/types.cjs

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/index.cjs

@@ -0,0 +1,16 @@
+"use strict";
+/**
+ * A flexible, provider-agnostic OAuth 2.0 and OpenID Connect (OIDC) client library for backend applications.
+ *
+ * @remarks
+ * This package simplifies multi-provider authentication flows (e.g., Google, GitHub), supports extensible session management, and enables custom provider registration.
+ *
+ * @packageDocumentation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultSessionStrategy = exports.Lixa = void 0;
+var lixa_1 = require("./lixa");
+Object.defineProperty(exports, "Lixa", { enumerable: true, get: function () { return lixa_1.Lixa; } });
+var session_1 = require("./models/session");
+Object.defineProperty(exports, "DefaultSessionStrategy", { enumerable: true, get: function () { return session_1.DefaultSessionStrategy; } });
+//# sourceMappingURL=index.js.map

package/dist/lixa.cjs

@@ -0,0 +1,295 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Lixa = void 0;
+const crypto_1 = require("crypto");
+const state_cache_1 = require("./dao/state-cache");
+const crypto_2 = __importDefault(require("crypto"));
+const session_cache_1 = require("./dao/session-cache");
+const session_1 = require("./models/session");
+/**
+ * A flexible, provider-agnostic OAuth 2.0 and OpenID Connect (OIDC) client library.
+ *
+ * @remarks
+ * Lixa simplifies multi-provider authentication flows and supports extensible session management.
+ *
+ * @example
+ * ```typescript
+ * import { Lixa } from '@vunexa/lixa';
+ * import { GoogleProvider } from '@vunexa/lixa/providers';
+ *
+ * // Register providers before using them
+ * Lixa.registerProvider({ google: new GoogleProvider() });
+ *
+ * const config = Lixa.createConfig({
+ *   providers: {
+ *     google: {
+ *       clientId: 'your-client-id',
+ *       clientSecret: 'your-client-secret',
+ *       redirectUri: 'https://yourapp.com/auth/google/callback',
+ *       scopes: ['openid', 'email', 'profile']
+ *     }
+ *   }
+ * });
+ *
+ * const lixa = new Lixa(config);
+ * ```
+ *
+ * @public
+ */
+class Lixa {
+    static CONFIGURED_PROVIDERS = new Map();
+    static LOCAL_STATE_CACHE = new state_cache_1.LocalStateCache();
+    static LOCAL_SESSION_CACHE = new session_cache_1.LocalSessionCache();
+    static DEFAULT_SESSION_STRATEGY = new session_1.DefaultSessionStrategy();
+    config;
+    stateDao;
+    sesionDao;
+    sessionStrategy;
+    /**
+     * Creates a new Lixa instance with the provided configuration.
+     *
+     * @param config - The configuration object containing provider settings and optional session strategy
+     */
+    constructor(config) {
+        // Validate that all providers in config are registered
+        const configuredProviders = Object.keys(config.providers);
+        const registeredProviders = Lixa.getRegisteredProviders();
+        for (const provider of configuredProviders) {
+            if (!registeredProviders.includes(provider.toLowerCase())) {
+                throw new Error(`Provider '${provider}' is not registered. Please register it first using Lixa.registerProvider()`);
+            }
+        }
+        this.config = config;
+        this.stateDao = config.stateDao || Lixa.LOCAL_STATE_CACHE;
+        this.sesionDao = config.sessionDao || Lixa.LOCAL_SESSION_CACHE;
+        this.sessionStrategy = config.sessionStrategy || Lixa.DEFAULT_SESSION_STRATEGY;
+    }
+    /**
+     * Checks if a provider is both registered and configured for this instance.
+     * This is a type guard that narrows the provider type for use with getAuthUrl.
+     *
+     * @param provider - The provider name to check (case-insensitive)
+     * @returns True if the provider is registered and configured, false otherwise
+     *
+     * @example
+     * ```typescript
+     * if (lixa.isProviderConfigured(provider)) {
+     *   // TypeScript now knows provider is a valid ConfiguredProviderKey
+     *   const authUrl = lixa.getAuthUrl(provider, state);
+     * }
+     * ```
+     */
+    isProviderConfigured(provider) {
+        const providerType = provider.toLowerCase();
+        return Lixa.CONFIGURED_PROVIDERS.has(providerType) &&
+            this.config.providers.hasOwnProperty(providerType);
+    }
+    /**
+     * Registers custom OAuth providers for use with Lixa.
+     *
+     * @param providerMap - A map of provider names to IProvider implementations
+     *
+     * @example
+     * ```typescript
+     * class CustomProvider implements IProvider {
+     *   authorizationEndpoint = 'https://custom.com/oauth/authorize';
+     *   tokenEndpoint = 'https://custom.com/oauth/token';
+     *   userInfoEndpoint = 'https://custom.com/api/user';
+     * }
+     *
+     * Lixa.registerProvider({ custom: new CustomProvider() });
+     * ```
+     */
+    static registerProvider(providerMap) {
+        Object.entries(providerMap).forEach(([key, providerImpl]) => {
+            Lixa.CONFIGURED_PROVIDERS.set(key.toLowerCase(), providerImpl);
+        });
+    }
+    /**
+     * Gets the list of registered provider names.
+     *
+     * @returns Array of registered provider names
+     */
+    static getRegisteredProviders() {
+        return Array.from(Lixa.CONFIGURED_PROVIDERS.keys());
+    }
+    /**
+     * Creates a type-safe configuration that only allows registered providers.
+     *
+     * @param config - Configuration object with providers that must be registered
+     * @returns The same configuration object, but with type safety for registered providers
+     */
+    static createConfig(config) {
+        // Validate that all providers in config are registered
+        const configuredProviders = Object.keys(config.providers);
+        const registeredProviders = Lixa.getRegisteredProviders();
+        for (const provider of configuredProviders) {
+            if (!registeredProviders.includes(provider.toLowerCase())) {
+                throw new Error(`Provider '${provider}' is not registered. Please register it first using Lixa.registerProvider()`);
+            }
+        }
+        return config;
+    }
+    /**
+     * Generates a cryptographically secure random state parameter for OAuth flows.
+     *
+     * @returns A 32-character hexadecimal string
+     *
+     * @remarks
+     * The state parameter is used to prevent CSRF attacks in OAuth flows.
+     */
+    static generateRandomState() {
+        return (0, crypto_1.randomBytes)(16).toString("hex");
+    }
+    /**
+     * Generates a cryptographically secure code verifier for PKCE flows.
+     *
+     * @returns A 64-character hexadecimal string
+     *
+     * @remarks
+     * The code verifier is used in PKCE (Proof Key for Code Exchange) to enhance security.
+     */
+    static generateCodeVerifier() {
+        return (0, crypto_1.randomBytes)(32).toString("hex");
+    }
+    static buildCodeChallenge(codeVerifier) {
+        const hash = crypto_2.default
+            .createHash("sha256")
+            .update(codeVerifier)
+            .digest("base64");
+        // Convert to base64url
+        return hash.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+    }
+    /**
+     * Generates the authorization URL for the specified provider.
+     *
+     * @param provider - The provider name (must be a configured provider key)
+     * @param state - The state parameter for CSRF protection
+     * @returns The complete authorization URL to redirect users to
+     *
+     * @throws Error when the provider is not configured
+     *
+     * @example
+     * ```typescript
+     * const state = Lixa.generateRandomState();
+     * const authUrl = lixa.getAuthUrl('google', state);
+     * res.redirect(authUrl);
+     * ```
+     */
+    getAuthUrl(provider, state) {
+        const providerType = String(provider).toLowerCase();
+        const providerConfig = this.findProviderByType(providerType);
+        const providerImpl = Lixa.CONFIGURED_PROVIDERS.get(providerType);
+        if (!providerConfig || !providerImpl) {
+            throw new Error(`Provider ${providerType} not configured`);
+        }
+        const codeVerifier = Lixa.generateCodeVerifier();
+        const codeChallenge = Lixa.buildCodeChallenge(codeVerifier);
+        // Cache the state paramaeter with TTL of 5 minutes (300 seconds)
+        // We dont care about value. we are onl interested in key existence
+        this.stateDao.saveState(state, {
+            createdAt: Date.now(),
+            provider: providerType,
+            codeVerifier,
+        }, 300 // 5 minutes in seconds
+        );
+        const params = new URLSearchParams({
+            client_id: providerConfig.clientId,
+            redirect_uri: providerConfig.redirectUri,
+            scope: providerConfig.scopes.join(" "),
+            state,
+            response_type: "code",
+            code_challenge: codeChallenge,
+            code_challenge_method: "S256",
+            ...providerConfig.extraConfig,
+        });
+        return `${providerImpl.authorizationEndpoint}?${params.toString()}`;
+    }
+    /**
+     * Handles the OAuth callback and creates a user session.
+     *
+     * @param provider - The provider name (must be a configured provider key)
+     * @param code - The authorization code from the provider
+     * @param state - The state parameter for validation
+     * @returns A Promise that resolves to the session ID
+     *
+     * @throws Error when code or state is missing/invalid, or provider is not configured
+     *
+     * @example
+     * ```typescript
+     * const sessionId = await lixa.handleCallback({
+     *   provider: 'google',
+     *   code: req.query.code,
+     *   state: req.query.state
+     * });
+     * ```
+     */
+    async handleCallback({ provider, code, state, }) {
+        if (!code || code.trim() === "") {
+            throw new Error("Invalid or missing code in callback");
+        }
+        if (!state || state.trim() === "") {
+            throw new Error("Invalid or missing state in callback");
+        }
+        //Validate state here
+        const cachedState = await this.stateDao.getState(state);
+        if (!cachedState) {
+            throw new Error("Invalid or expired state");
+        }
+        // State is valid, remove it from cache to prevent reuse
+        await this.stateDao.deleteState(state);
+        //Get code verifier from cached state
+        const codeVerifier = cachedState.codeVerifier;
+        const providerType = String(provider).toLowerCase();
+        const providerConfig = this.findProviderByType(providerType);
+        const providerImpl = Lixa.CONFIGURED_PROVIDERS.get(providerType);
+        if (!providerConfig || !providerImpl) {
+            throw new Error(`Provider ${String(provider)} not configured`);
+        }
+        // Exchange code for tokens and fetch user info here.
+        const tokens = await this.exchangeCodeForToken(code, providerConfig, providerImpl, codeVerifier);
+        const session = await this.sessionStrategy.createSession(tokens);
+        // Generate unique session ID
+        const sessionId = (0, crypto_1.randomBytes)(32).toString("hex");
+        // Store session with 24 hour TTL (86400 seconds)
+        await this.sesionDao.saveSession(sessionId, session, 86400);
+        return sessionId;
+    }
+    fetchSessionInfo(sessionId) {
+        return this.sesionDao.getSession(sessionId);
+    }
+    async exchangeCodeForToken(code, providerConfig, providerImpl, codeVerifier) {
+        // Build the request body
+        const body = {
+            client_id: providerConfig.clientId,
+            client_secret: providerConfig.clientSecret,
+            code,
+            redirect_uri: providerConfig.redirectUri,
+            grant_type: "authorization_code",
+        };
+        if (codeVerifier) {
+            body.code_verifier = codeVerifier;
+        }
+        const params = new URLSearchParams(body);
+        const response = await fetch(providerImpl.tokenEndpoint, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/x-www-form-urlencoded",
+                Accept: "application/json",
+            },
+            body: params.toString(),
+        });
+        if (!response.ok) {
+            throw new Error(`Token exchange failed: ${response.status} ${response.statusText}`);
+        }
+        return response.json();
+    }
+    findProviderByType(providerType) {
+        return this.config.providers[providerType];
+    }
+}
+exports.Lixa = Lixa;
+//# sourceMappingURL=lixa.js.map

package/dist/models/session.cjs

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultSessionStrategy = void 0;
+/**
+ * Default session strategy that works with any OAuth provider.
+ * Extracts common token information and creates a standardized session.
+ *
+ * @public
+ */
+class DefaultSessionStrategy {
+    /**
+     * Creates a session from OAuth token data.
+     * Handles common OAuth token formats and extracts the access token.
+     *
+     * @param tokenData - The token data received from the OAuth provider
+     * @returns A Promise that resolves to a Session object
+     */
+    async createSession(tokenData) {
+        // Extract access token from various possible formats
+        const accessToken = tokenData.access_token ||
+            tokenData.accessToken ||
+            tokenData.token ||
+            tokenData;
+        if (!accessToken || typeof accessToken !== 'string') {
+            throw new Error('No valid access token found in OAuth response');
+        }
+        return {
+            token: accessToken,
+            raw: tokenData,
+        };
+    }
+}
+exports.DefaultSessionStrategy = DefaultSessionStrategy;
+//# sourceMappingURL=session.js.map

package/dist/providers/IProvider.cjs

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=IProvider.js.map

package/dist/providers/github.cjs

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GithubProvider = void 0;
+/**
+ * GitHub OAuth provider implementation
+ * @public
+ */
+class GithubProvider {
+    providerType = "GITHUB";
+    authorizationEndpoint = "https://github.com/login/oauth/authorize";
+    tokenEndpoint = "https://github.com/login/oauth/access_token";
+    userInfoEndpoint = "https://api.github.com/user";
+}
+exports.GithubProvider = GithubProvider;
+//# sourceMappingURL=github.js.map

package/dist/providers/google.cjs

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GoogleProvider = void 0;
+/**
+ * Google OAuth provider implementation
+ * @public
+ */
+class GoogleProvider {
+    providerType = "GOOGLE";
+    authorizationEndpoint = "https://accounts.google.com/o/oauth2/v2/auth";
+    tokenEndpoint = "https://oauth2.googleapis.com/token";
+    userInfoEndpoint = "https://www.googleapis.com/oauth2/v2/userinfo";
+}
+exports.GoogleProvider = GoogleProvider;
+//# sourceMappingURL=google.js.map

package/dist/providers/index.cjs

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GoogleProvider = exports.GithubProvider = void 0;
+var github_1 = require("./github");
+Object.defineProperty(exports, "GithubProvider", { enumerable: true, get: function () { return github_1.GithubProvider; } });
+var google_1 = require("./google");
+Object.defineProperty(exports, "GoogleProvider", { enumerable: true, get: function () { return google_1.GoogleProvider; } });
+//# sourceMappingURL=index.js.map

package/dist/providers-entry.cjs

@@ -0,0 +1,27 @@
+"use strict";
+/**
+ * Built-in OAuth providers for Lixa
+ *
+ * @remarks
+ * Import and register these providers before using them in your Lixa configuration.
+ *
+ * @example
+ * ```typescript
+ * import { Lixa } from '@vunexa/lixa';
+ * import { GoogleProvider, GithubProvider } from '@vunexa/lixa/providers';
+ *
+ * // Register the providers you want to use
+ * Lixa.registerProvider({
+ *   google: new GoogleProvider(),
+ *   github: new GithubProvider(),
+ * });
+ * ```
+ *
+ * @packageDocumentation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GithubProvider = exports.GoogleProvider = void 0;
+var providers_1 = require("./providers");
+Object.defineProperty(exports, "GoogleProvider", { enumerable: true, get: function () { return providers_1.GoogleProvider; } });
+Object.defineProperty(exports, "GithubProvider", { enumerable: true, get: function () { return providers_1.GithubProvider; } });
+//# sourceMappingURL=providers-entry.js.map

package/dist/types.cjs

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/utils/constants.cjs

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GITHUB = exports.GOOGLE = void 0;
+const GOOGLE = "google";
+exports.GOOGLE = GOOGLE;
+const GITHUB = "github";
+exports.GITHUB = GITHUB;
+//# sourceMappingURL=constants.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vunexa/lixa",
-  "version": "0.0.1-alpha.13",
+  "version": "0.0.1-alpha.14",
   "description": "Lixa is a flexible, provider-agnostic OAuth and OpenID Connect (OIDC) client library that simplifies multi-provider authentication flows. It supports seamless integration with providers like Google and GitHub, offers extensible session management, and enables dynamic provider resolution based on callback URLs.",
   "keywords": [
     "oauth",
@@ -14,16 +14,20 @@
   "exports": {
     ".": {
       "types": "./dist/export-types/index.d.ts",
-      "import": "./dist/index.js"
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
     },
     "./providers": {
       "types": "./dist/export-types/providers.d.ts",
-      "import": "./dist/providers-entry.js"
+      "import": "./dist/providers-entry.js",
+      "require": "./dist/providers-entry.cjs"
     }
   },
   "scripts": {
-    "build": "tsc && npm run test && api-extractor run --local && api-extractor run --local --config api-extractor-providers.json",
-    "clean": "rm -rf dist",
+    "build": "npm run build:esm && npm run build:cjs && npm run test && api-extractor run --local && api-extractor run --local --config api-extractor-providers.json",
+    "build:esm": "tsc",
+    "build:cjs": "tsc --module commonjs --outDir dist-cjs && node scripts/rename-cjs.cjs",
+    "clean": "rm -rf dist dist-cjs",
     "prepublishOnly": "npm run clean && npm run build",
     "lint": "eslint src/**/*.ts",
     "lint:fix": "eslint src/**/*.ts --fix",