auth0 6.4.0 → 7.0.0

package/dist/esm/lib/errors.d.mts

@@ -1,13 +1,3 @@
-/**
- * Error thrown when the API returns an error response that can't be parsed to a more specific Error instance.
- */
-export declare class ResponseError extends Error {
-    statusCode: number;
-    body: string;
-    headers: Headers;
-    name: "ResponseError";
-    constructor(statusCode: number, body: string, headers: Headers, msg?: string);
-}
 /**
  * Error thrown when the request is aborted due to a timeout.
  */
@@ -15,14 +5,6 @@ export declare class TimeoutError extends Error {
     name: "TimeoutError";
     constructor();
 }
-/**
- * Error thrown when there is a network error.
- */
-export declare class FetchError extends Error {
-    cause: Error;
-    name: "FetchError";
-    constructor(cause: Error, msg?: string);
-}
 /**
  * Error thrown when a required argument was not provided.
  */

package/dist/esm/lib/errors.mjs

@@ -1,15 +1,3 @@
-/**
- * Error thrown when the API returns an error response that can't be parsed to a more specific Error instance.
- */
-export class ResponseError extends Error {
-    constructor(statusCode, body, headers, msg) {
-        super(msg);
-        this.statusCode = statusCode;
-        this.body = body;
-        this.headers = headers;
-        this.name = "ResponseError";
-    }
-}
 /**
  * Error thrown when the request is aborted due to a timeout.
  */
@@ -19,16 +7,6 @@ export class TimeoutError extends Error {
         this.name = "TimeoutError";
     }
 }
-/**
- * Error thrown when there is a network error.
- */
-export class FetchError extends Error {
-    constructor(cause, msg) {
-        super(msg);
-        this.cause = cause;
-        this.name = "FetchError";
-    }
-}
 /**
  * Error thrown when a required argument was not provided.
  */

package/dist/esm/lib/middleware/auth0-client-telemetry.d.mts

@@ -1,10 +1,9 @@
-import { Middleware, ClientOptions, FetchParams, RequestContext } from "../runtime.mjs";
+import { ClientOptions } from "../models.mjs";
 /**
- * Handles Auth0 client telemetry functionality. Can be used both as middleware
- * for automatic header injection and as a standalone utility for manual telemetry header generation.
+ * Generates the Auth0-Client telemetry header value.
  * @private
  */
-export declare class Auth0ClientTelemetry implements Middleware {
+export declare class Auth0ClientTelemetry {
     clientInfo: {
         name: string;
         [key: string]: unknown;
@@ -12,9 +11,6 @@ export declare class Auth0ClientTelemetry implements Middleware {
     constructor(options: ClientOptions);
     /**
      * Get the Auth0-Client header value for telemetry.
-     * This method can be used when you need to manually add telemetry headers
-     * instead of using the middleware system.
      */
     getAuth0ClientHeader(): string | undefined;
-    pre?(context: RequestContext): Promise<FetchParams | void>;
 }

package/dist/esm/lib/middleware/auth0-client-telemetry.mjs

@@ -1,17 +1,7 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 import { generateClientInfo } from "../../utils.mjs";
 import { base64url } from "jose";
 /**
- * Handles Auth0 client telemetry functionality. Can be used both as middleware
- * for automatic header injection and as a standalone utility for manual telemetry header generation.
+ * Generates the Auth0-Client telemetry header value.
  * @private
  */
 export class Auth0ClientTelemetry {
@@ -20,8 +10,6 @@ export class Auth0ClientTelemetry {
     }
     /**
      * Get the Auth0-Client header value for telemetry.
-     * This method can be used when you need to manually add telemetry headers
-     * instead of using the middleware system.
      */
     getAuth0ClientHeader() {
         if ("string" === typeof this.clientInfo.name && this.clientInfo.name.length > 0) {
@@ -29,16 +17,4 @@ export class Auth0ClientTelemetry {
         }
         return undefined;
     }
-    pre(context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const headerValue = this.getAuth0ClientHeader();
-            if (headerValue) {
-                context.init.headers = Object.assign(Object.assign({}, context.init.headers), { "Auth0-Client": headerValue });
-            }
-            return {
-                url: context.url,
-                init: context.init,
-            };
-        });
-    }
 }

package/dist/esm/lib/models.d.mts

@@ -71,30 +71,6 @@ export interface ApiResponse<T> {
     status: number;
     statusText: string;
 }
-export declare class JSONApiResponse<T> implements ApiResponse<T> {
-    data: T;
-    headers: Headers;
-    readonly status: number;
-    readonly statusText: string;
-    constructor(data: T, headers: Headers, status: number, statusText: string);
-    static fromResponse<T = unknown>(raw: Response): Promise<JSONApiResponse<T>>;
-}
-export declare class VoidApiResponse implements ApiResponse<undefined> {
-    headers: Headers;
-    readonly status: number;
-    readonly statusText: string;
-    data: undefined;
-    constructor(headers: Headers, status: number, statusText: string);
-    static fromResponse(raw: Response): Promise<VoidApiResponse>;
-}
-export declare class TextApiResponse implements ApiResponse<string> {
-    data: string;
-    headers: Headers;
-    readonly status: number;
-    readonly statusText: string;
-    constructor(data: string, headers: Headers, status: number, statusText: string);
-    static fromResponse(raw: Response): Promise<TextApiResponse>;
-}
 export interface FetchParams {
     url: string | URL | Request;
     init: RequestInit;

package/dist/esm/lib/models.mjs

@@ -1,49 +1 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-export class JSONApiResponse {
-    constructor(data, headers, status, statusText) {
-        this.data = data;
-        this.headers = headers;
-        this.status = status;
-        this.statusText = statusText;
-    }
-    static fromResponse(raw) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const value = (yield raw.json());
-            return new JSONApiResponse(value, raw.headers, raw.status, raw.statusText);
-        });
-    }
-}
-export class VoidApiResponse {
-    constructor(headers, status, statusText) {
-        this.headers = headers;
-        this.status = status;
-        this.statusText = statusText;
-    }
-    static fromResponse(raw) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return new VoidApiResponse(raw.headers, raw.status, raw.statusText);
-        });
-    }
-}
-export class TextApiResponse {
-    constructor(data, headers, status, statusText) {
-        this.data = data;
-        this.headers = headers;
-        this.status = status;
-        this.statusText = statusText;
-    }
-    static fromResponse(raw) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const value = yield raw.text();
-            return new TextApiResponse(value, raw.headers, raw.status, raw.statusText);
-        });
-    }
-}
+export {};

package/dist/esm/management/version.d.mts

@@ -1 +1 @@
-export declare const SDK_VERSION = "6.4.0";
+export declare const SDK_VERSION = "7.0.0";

package/dist/esm/management/version.mjs

@@ -1 +1 @@
-export const SDK_VERSION = "6.4.0";
+export const SDK_VERSION = "7.0.0";

package/dist/esm/management/wrapper/ManagementClient.d.mts

@@ -15,7 +15,7 @@ export declare namespace ManagementClient {
      * @group Management API
      * @public
      */
-    interface ManagementClientOptions extends Omit<FernClient.Options, "token" | "environment" | "fetcher" | "baseUrl" | "fetch"> {
+    interface ManagementClientOptions extends Omit<FernClient.Options, "token" | "environment" | "fetcher" | "baseUrl"> {
         /** Auth0 domain (e.g., 'your-tenant.auth0.com') */
         domain: string;
         /**
@@ -114,7 +114,14 @@ export declare namespace ManagementClient {
         clientAssertionSigningKey: string;
         /** Algorithm for signing the client assertion. Defaults to RS256 */
         clientAssertionSigningAlg?: string;
-        /** Enable mTLS for token endpoint calls */
+        /**
+         * Enable mTLS for token endpoint calls.
+         *
+         * mTLS (RFC 8705) is a transport-layer concern that is independent of the client
+         * authentication method: a client authenticating with `private_key_jwt` can still present a
+         * TLS client certificate to obtain a certificate-bound access token. This mirrors v6, which
+         * added the `mtls.` endpoint alias from `useMTLS` alone regardless of the auth method.
+         */
         useMTLS?: boolean;
     }
     /**

package/dist/esm/management/wrapper/ManagementClient.mjs

@@ -71,7 +71,6 @@ export class ManagementClient extends FernClient {
         const token = createTokenSupplier(_options);
         // Temporarily remove fetcher from options to avoid people passing it for now
         delete _options.fetcher;
-        delete _options.fetch;
         // Prepare the base client options
         let clientOptions = Object.assign(Object.assign({}, _options), { baseUrl,
             headers,

package/dist/esm/management/wrapper/token-provider.d.mts

@@ -1,7 +1,6 @@
-import { ManagementClient } from "./ManagementClient.mjs";
+import type { ManagementClient } from "./ManagementClient.mjs";
 export declare class TokenProvider {
     private readonly options;
-    private authenticationClient;
     private expiresAt;
     private accessToken;
     private pending;
@@ -12,4 +11,7 @@ export declare class TokenProvider {
         audience: string;
     });
     getAccessToken(): Promise<string>;
+    private fetchToken;
+    private buildClientAssertion;
+    private buildTelemetryHeader;
 }

package/dist/esm/management/wrapper/token-provider.mjs

@@ -7,30 +7,161 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { AuthenticationClient } from "../../auth/index.mjs";
-const LEEWAY = 10 * 1000;
+import { base64url, importPKCS8, SignJWT } from "jose";
+import { generateClientInfo } from "../../utils.mjs";
+import { ManagementError } from "../errors/ManagementError.mjs";
+const LEEWAY = 10 * 1000; // 10s refresh-ahead in ms
 export class TokenProvider {
     constructor(options) {
         this.options = options;
         this.expiresAt = 0;
         this.accessToken = "";
-        this.authenticationClient = new AuthenticationClient(Object.assign(Object.assign({}, options), { headers: options.headers }));
+        // Validate domain: must be a bare hostname, no slashes or query strings.
+        if (/[/?#]/.test(options.domain)) {
+            throw new Error(`ManagementClient: invalid domain "${options.domain}". Provide a bare hostname, e.g. "tenant.auth0.com".`);
+        }
+        if (options.useMTLS) {
+            const { fetch: customFetch } = options;
+            if (!customFetch) {
+                throw new Error("ManagementClient: useMTLS requires a custom fetch implementation. " +
+                    "Provide a `fetch` option configured with your mTLS client certificate.");
+            }
+            // mTLS (RFC 8705) is a transport-layer concern independent of the client authentication
+            // method. It combines with both `clientSecret` and `clientAssertionSigningKey`: the TLS
+            // client certificate yields a certificate-bound token regardless of how the client
+            // authenticates. v6 supported this, so no auth-method restriction is imposed here.
+        }
     }
     getAccessToken() {
         return __awaiter(this, void 0, void 0, function* () {
             if (!this.accessToken || Date.now() > this.expiresAt - LEEWAY) {
-                this.pending =
-                    this.pending ||
-                        this.authenticationClient.oauth.clientCredentialsGrant({
-                            audience: this.options.audience,
-                        });
-                const { data: { access_token: accessToken, expires_in: expiresIn }, } = yield this.pending.finally(() => {
+                this.pending = this.pending || this.fetchToken();
+                const result = yield this.pending.finally(() => {
                     delete this.pending;
                 });
-                this.expiresAt = Date.now() + expiresIn * 1000;
-                this.accessToken = accessToken;
+                this.expiresAt = result.expiresAt;
+                this.accessToken = result.accessToken;
             }
             return this.accessToken;
         });
     }
+    fetchToken() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const { domain, clientId, audience } = this.options;
+            const tokenUrl = this.options.useMTLS ? `https://mtls.${domain}/oauth/token` : `https://${domain}/oauth/token`;
+            const body = new URLSearchParams({
+                grant_type: "client_credentials",
+                client_id: clientId,
+                audience,
+            });
+            if ("clientSecret" in this.options) {
+                body.set("client_secret", this.options.clientSecret);
+            }
+            else if ("clientAssertionSigningKey" in this.options) {
+                const assertion = yield this.buildClientAssertion(domain, clientId);
+                body.set("client_assertion", assertion);
+                body.set("client_assertion_type", "urn:ietf:params:oauth:client-assertion-type:jwt-bearer");
+            }
+            // Build request headers. Start with user-supplied plain-string headers so they can be
+            // overridden by SDK-controlled values (Content-Type, Auth0-Client) set below.
+            // Supplier-function headers (Fern's Supplier<string | null | undefined> type) are skipped —
+            // they require async resolution and are not supported on the token endpoint path.
+            const userHeaders = (_a = this.options.headers) !== null && _a !== void 0 ? _a : {};
+            const headers = {};
+            for (const [key, value] of Object.entries(userHeaders)) {
+                if (typeof value === "string") {
+                    headers[key.toLowerCase()] = value;
+                }
+            }
+            headers["content-type"] = "application/x-www-form-urlencoded";
+            const telemetryHeader = this.buildTelemetryHeader();
+            if (telemetryHeader) {
+                headers["auth0-client"] = telemetryHeader;
+            }
+            // Use custom fetch for mTLS, else global fetch.
+            // `fetch` is defined on BaseClientOptions (src/management/BaseClient.ts) which is Fern-generated.
+            // If that file is regenerated, verify `fetch?: typeof fetch` is still present — token acquisition
+            // for mTLS depends on it being forwarded here.
+            const { fetch: customFetch } = this.options;
+            const fetcher = customFetch !== null && customFetch !== void 0 ? customFetch : fetch;
+            let response;
+            try {
+                response = yield fetcher(tokenUrl, {
+                    method: "POST",
+                    headers,
+                    body: body.toString(),
+                    signal: AbortSignal.timeout(10000),
+                });
+            }
+            catch (err) {
+                // Built-in fetch aborts with a "TimeoutError"; node-fetch (used on the mTLS path with a
+                // custom fetch) aborts with an "AbortError". Match both so a token-request timeout maps
+                // to a 408 regardless of the underlying fetch implementation.
+                if (err instanceof Error && (err.name === "TimeoutError" || err.name === "AbortError")) {
+                    throw new ManagementError({
+                        message: "ManagementClient: token request timed out",
+                        statusCode: 408,
+                    });
+                }
+                throw err;
+            }
+            if (!response.ok) {
+                // Read the body exactly once. `response.json()` followed by `response.text()` throws
+                // "Body has already been read", which would swallow non-JSON error payloads (e.g. proxy
+                // or WAF 502s). Read text, then attempt to parse it as JSON.
+                const raw = yield response.text().catch(() => "");
+                let errorBody;
+                try {
+                    errorBody = raw ? JSON.parse(raw) : response.statusText;
+                }
+                catch (_b) {
+                    errorBody = raw || response.statusText;
+                }
+                throw new ManagementError({
+                    message: "ManagementClient: token request failed",
+                    statusCode: response.status,
+                    body: errorBody,
+                });
+            }
+            const json = (yield response.json());
+            return {
+                accessToken: json.access_token,
+                expiresAt: Date.now() + json.expires_in * 1000,
+            };
+        });
+    }
+    buildClientAssertion(domain, clientId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { clientAssertionSigningKey, clientAssertionSigningAlg = "RS256" } = this
+                .options;
+            const key = yield importPKCS8(clientAssertionSigningKey, clientAssertionSigningAlg);
+            const now = Math.floor(Date.now() / 1000);
+            return new SignJWT({})
+                .setProtectedHeader({ alg: clientAssertionSigningAlg })
+                .setIssuedAt(now)
+                .setIssuer(clientId)
+                .setSubject(clientId)
+                .setAudience(`https://${domain}/`)
+                .setExpirationTime(now + 180) // 3 min lifetime
+                .setJti(crypto.randomUUID())
+                .sign(key);
+        });
+    }
+    buildTelemetryHeader() {
+        var _a;
+        const opts = this.options;
+        if (opts.telemetry === false)
+            return null;
+        const nodeAuth0Info = generateClientInfo();
+        const info = opts.clientInfo
+            ? { name: opts.clientInfo.name, version: String((_a = opts.clientInfo.version) !== null && _a !== void 0 ? _a : nodeAuth0Info.version) }
+            : { name: nodeAuth0Info.name, version: nodeAuth0Info.version };
+        // NOTE: auth0-auth-js TelemetryConfig does not support env fields.
+        // The runtime fingerprint (env.node / env.cloudflare-workers) present in the
+        // original node-auth0 Auth0-Client header is intentionally omitted here.
+        // This is a known, accepted delta vs the pre-v7 token request telemetry shape.
+        // Use jose's base64url encoder for runtime portability (Buffer is Node-only).
+        return base64url.encode(new TextEncoder().encode(JSON.stringify(info)));
+    }
 }

package/dist/esm/utils.d.mts

@@ -5,21 +5,3 @@ export declare const generateClientInfo: () => {
         [x: string]: string;
     };
 };
-/**
- * @private
- */
-export declare const mtlsPrefix = "mtls";
-type SyncGetter<T> = () => T;
-type AsyncGetter<T> = () => Promise<T>;
-/**
- * Resolves a value that can be a static value, a synchronous function, or an asynchronous function.
- *
- * @template T - The type of the value to be resolved.
- * @param {T | SyncGetter<T> | AsyncGetter<T>} value - The value to be resolved. It can be:
- *   - A static value of type T.
- *   - A synchronous function that returns a value of type T.
- *   - An asynchronous function that returns a Promise of type T.
- * @returns {Promise<T>} A promise that resolves to the value of type T.
- */
-export declare const resolveValueToPromise: <T>(value: T | SyncGetter<T> | AsyncGetter<T>) => Promise<T>;
-export {};

package/dist/esm/utils.mjs

@@ -1,12 +1,3 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 import { SDK_VERSION as version } from "./management/version.mjs";
 import { RUNTIME } from "./management/core/index.mjs";
 export const generateClientInfo = () => {
@@ -22,24 +13,3 @@ export const generateClientInfo = () => {
         },
     };
 };
-/**
- * @private
- */
-export const mtlsPrefix = "mtls";
-/**
- * Resolves a value that can be a static value, a synchronous function, or an asynchronous function.
- *
- * @template T - The type of the value to be resolved.
- * @param {T | SyncGetter<T> | AsyncGetter<T>} value - The value to be resolved. It can be:
- *   - A static value of type T.
- *   - A synchronous function that returns a value of type T.
- *   - An asynchronous function that returns a Promise of type T.
- * @returns {Promise<T>} A promise that resolves to the value of type T.
- */
-export const resolveValueToPromise = (value) => __awaiter(void 0, void 0, void 0, function* () {
-    if (typeof value === "function") {
-        const result = value(); // Call the function
-        return result instanceof Promise ? result : Promise.resolve(result); // Handle sync/async
-    }
-    return Promise.resolve(value); // Static value
-});

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "auth0",
-    "version": "6.4.0",
+    "version": "7.0.0",
     "private": false,
     "repository": {
         "type": "git",
@@ -1732,7 +1732,6 @@
         "validate": "yarn lint:check && yarn format --check && yarn build && yarn test && yarn lint:package"
     },
     "dependencies": {
-        "uuid": "^11.1.1",
         "jose": "^5.0.0",
         "auth0-legacy": "npm:auth0@^4.37.1"
     },