@corti/sdk 0.10.1 → 1.0.0-alpha

package/dist/cjs/core/websocket/ws.js

@@ -39,13 +39,13 @@ const index_js_1 = require("../runtime/index.js");
 const qs_js_1 = require("../url/qs.js");
 const Events = __importStar(require("./events.js"));
 const getGlobalWebSocket = () => {
-    if (typeof WebSocket !== "undefined") {
+    if (index_js_1.RUNTIME.type === "node" || index_js_1.RUNTIME.type === "bun" || index_js_1.RUNTIME.type === "deno") {
+        return ws_1.WebSocket;
+    }
+    else if (typeof WebSocket !== "undefined") {
         // @ts-ignore
         return WebSocket;
     }
-    else if (index_js_1.RUNTIME.type === "node") {
-        return ws_1.WebSocket;
-    }
     return undefined;
 };
 /**
@@ -64,7 +64,7 @@ const DEFAULT_OPTIONS = {
     debug: false,
 };
 class ReconnectingWebSocket {
-    constructor({ url, protocols, options, headers, queryParameters }) {
+    constructor({ url, protocols, options, headers, queryParameters, abortSignal }) {
         this._listeners = {
             error: [],
             message: [],
@@ -77,6 +77,10 @@ class ReconnectingWebSocket {
         this._binaryType = "blob";
         this._closeCalled = false;
         this._messageQueue = [];
+        this.CONNECTING = ReconnectingWebSocket.CONNECTING;
+        this.OPEN = ReconnectingWebSocket.OPEN;
+        this.CLOSING = ReconnectingWebSocket.CLOSING;
+        this.CLOSED = ReconnectingWebSocket.CLOSED;
         /**
          * An event listener to be called when the WebSocket connection's readyState changes to CLOSED
          */
@@ -94,6 +98,25 @@ class ReconnectingWebSocket {
          * this indicates that the connection is ready to send and receive data
          */
         this.onopen = null;
+        this._handleAbort = () => {
+            if (this._closeCalled) {
+                return;
+            }
+            this._debug("abort signal fired");
+            this._shouldReconnect = false;
+            this._closeCalled = true;
+            this._clearTimeouts();
+            if (this._ws) {
+                this._removeListeners();
+                try {
+                    this._ws.close(1000, "aborted");
+                    this._handleClose(new Events.CloseEvent(1000, "aborted", this));
+                }
+                catch (_error) {
+                    // ignore
+                }
+            }
+        };
         this._handleOpen = (event) => {
             this._debug("open event");
             const { minUptime = DEFAULT_OPTIONS.minUptime } = this._options;
@@ -144,35 +167,15 @@ class ReconnectingWebSocket {
         this._options = options !== null && options !== void 0 ? options : DEFAULT_OPTIONS;
         this._headers = headers;
         this._queryParameters = queryParameters;
+        this._abortSignal = abortSignal;
+        if (this._abortSignal) {
+            this._abortSignal.addEventListener("abort", this._handleAbort, { once: true });
+        }
         if (this._options.startClosed) {
             this._shouldReconnect = false;
         }
         this._connect();
     }
-    static get CONNECTING() {
-        return 0;
-    }
-    static get OPEN() {
-        return 1;
-    }
-    static get CLOSING() {
-        return 2;
-    }
-    static get CLOSED() {
-        return 3;
-    }
-    get CONNECTING() {
-        return ReconnectingWebSocket.CONNECTING;
-    }
-    get OPEN() {
-        return ReconnectingWebSocket.OPEN;
-    }
-    get CLOSING() {
-        return ReconnectingWebSocket.CLOSING;
-    }
-    get CLOSED() {
-        return ReconnectingWebSocket.CLOSED;
-    }
     get binaryType() {
         return this._ws ? this._ws.binaryType : this._binaryType;
     }
@@ -330,7 +333,7 @@ class ReconnectingWebSocket {
         const { reconnectionDelayGrowFactor = DEFAULT_OPTIONS.reconnectionDelayGrowFactor, minReconnectionDelay = DEFAULT_OPTIONS.minReconnectionDelay, maxReconnectionDelay = DEFAULT_OPTIONS.maxReconnectionDelay, } = this._options;
         let delay = 0;
         if (this._retryCount > 0) {
-            delay = minReconnectionDelay * Math.pow(reconnectionDelayGrowFactor, this._retryCount - 1);
+            delay = minReconnectionDelay * Math.pow(reconnectionDelayGrowFactor, (this._retryCount - 1));
             if (delay > maxReconnectionDelay) {
                 delay = maxReconnectionDelay;
             }
@@ -360,9 +363,14 @@ class ReconnectingWebSocket {
         throw Error("Invalid URL");
     }
     _connect() {
+        var _a;
         if (this._connectLock || !this._shouldReconnect) {
             return;
         }
+        if ((_a = this._abortSignal) === null || _a === void 0 ? void 0 : _a.aborted) {
+            this._debug("connect aborted");
+            return;
+        }
         this._connectLock = true;
         const { maxRetries = DEFAULT_OPTIONS.maxRetries, connectionTimeout = DEFAULT_OPTIONS.connectionTimeout, WebSocket = getGlobalWebSocket(), } = this._options;
         if (this._retryCount >= maxRetries) {
@@ -378,7 +386,9 @@ class ReconnectingWebSocket {
         this._wait()
             .then(() => this._getNextUrl(this._url))
             .then((url) => {
-            if (this._closeCalled) {
+            var _a;
+            if (this._closeCalled || ((_a = this._abortSignal) === null || _a === void 0 ? void 0 : _a.aborted)) {
+                this._connectLock = false;
                 return;
             }
             const options = {};
@@ -412,7 +422,7 @@ class ReconnectingWebSocket {
             this._ws.close(code, reason);
             this._handleClose(new Events.CloseEvent(code, reason, this));
         }
-        catch (error) {
+        catch (_error) {
             // ignore
         }
     }
@@ -458,3 +468,7 @@ class ReconnectingWebSocket {
     }
 }
 exports.ReconnectingWebSocket = ReconnectingWebSocket;
+ReconnectingWebSocket.CONNECTING = 0;
+ReconnectingWebSocket.OPEN = 1;
+ReconnectingWebSocket.CLOSING = 2;
+ReconnectingWebSocket.CLOSED = 3;

package/dist/cjs/custom/BearerProvider.d.ts

@@ -0,0 +1,13 @@
+/**
+ * BearerProvider used as a replacement of OAuthTokenProvider, in case when BearerAuth was used instead of OAuth2.
+ */
+import * as core from "../core/index.js";
+interface Options {
+    accessToken: core.Supplier<string>;
+}
+export declare class BearerProvider {
+    private _accessToken;
+    constructor(_options: Options);
+    getToken(): Promise<string>;
+}
+export {};

package/dist/cjs/custom/BearerProvider.js

@@ -0,0 +1,60 @@
+"use strict";
+/**
+ * BearerProvider used as a replacement of OAuthTokenProvider, in case when BearerAuth was used instead of OAuth2.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BearerProvider = void 0;
+const core = __importStar(require("../core/index.js"));
+class BearerProvider {
+    constructor(_options) {
+        this._accessToken = _options.accessToken;
+    }
+    getToken() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return core.Supplier.get(this._accessToken);
+        });
+    }
+}
+exports.BearerProvider = BearerProvider;

package/dist/cjs/custom/CortiAuth.d.ts

@@ -1,131 +1,129 @@
-/**
- * This file is implementation of the Auth client that can be used in 2 scenarios:
- * 1. Under the hood by the package when Client credentials are used
- * 2. Directly imported by the user to implement Authorization code flow
- *
- * Locally based on the auto-generated Auth client (src/api/resources/auth/client/Client.ts), but with some changes:
- * 1. Token request sends proper `application/x-www-form-urlencoded` content type instead of `application/json`
- * 2. Token request accepts additional parameters to support Authorization code flow
- * 3. Additional methods to support Authorization code flow
- *
- * All methods are re-implemented, but class still extends the auto-generated one to make sure that we keep the same interface
- *  and to maybe remove some of the re-implementations in the future when `x-www-form-urlencoded` is supported
- */
-import { Auth as FernAuth } from "../api/resources/auth/client/Client.js";
+import type * as Corti from "../api/index.js";
+import { AuthClient } from "../api/resources/auth/client/Client.js";
+import type { OAuthAuthProvider } from "../auth/OAuthAuthProvider.js";
 import * as core from "../core/index.js";
-import * as Corti from "../api/index.js";
-import { Environment, CortiInternalEnvironment } from "./utils/getEnvironmentFromString.js";
-/**
- * Patch: added codeChallenge to the AuthorizationCodeClient interface to support PKCE flow
- */
-interface AuthorizationCodeClient {
-    clientId: string;
-    redirectUri: string;
-    codeChallenge?: string;
-    scopes?: string[];
-}
-/**
- * Patch: renamed AuthorizationCodeClient to AuthorizationCode as it can be used for both(server and client) flows
- */
-interface AuthorizationCode {
-    clientId: string;
-    clientSecret: string;
-    redirectUri: string;
-    code: string;
-    scopes?: string[];
-}
-/**
- * Patch: added type for AuthorizationPkce request
- */
-interface AuthorizationPkce {
-    clientId: string;
-    redirectUri: string;
-    code: string;
-    codeVerifier?: string;
-    scopes?: string[];
-}
-/**
- * Patch: added type for AuthorizationRopc request
- */
-interface AuthorizationRopcServer {
-    clientId: string;
-    username: string;
-    password: string;
-    scopes?: string[];
-}
-interface AuthorizationRefreshServer {
-    clientId: string;
-    /**
-     * Patch: added optional clientSecret for ROPC and PKCE flow
-     */
-    clientSecret?: string;
-    refreshToken: string;
-    scopes?: string[];
-}
+import { type Environment } from "./utils/environment.js";
 interface Options {
     skipRedirect?: boolean;
 }
-type AuthOptionsBase = Omit<FernAuth.Options, "environment" | "tenantName" | "baseUrl">;
-type AuthOptionsWithBaseUrl = AuthOptionsBase & {
-    baseUrl: core.Supplier<string>;
-    environment?: Environment;
-    tenantName?: core.Supplier<string>;
-};
-type AuthOptionsWithObjectEnvironment = AuthOptionsBase & {
-    baseUrl?: core.Supplier<string>;
-    environment: CortiInternalEnvironment;
-    tenantName?: core.Supplier<string>;
-};
-type AuthOptionsWithStringEnvironment = AuthOptionsBase & {
-    baseUrl?: core.Supplier<string>;
-    environment: string;
-    tenantName: core.Supplier<string>;
-};
-type AuthOptions = AuthOptionsWithBaseUrl | AuthOptionsWithObjectEnvironment | AuthOptionsWithStringEnvironment;
-export declare class Auth extends FernAuth {
-    /**
-     * Patch: use custom AuthOptions type to support string-based environment
-     * When baseUrl is provided, environment and tenantName become optional
-     */
-    constructor(_options: AuthOptions);
-    /**
-     * Patch: Generate PKCE authorization URL with automatic code verifier generation
-     */
-    authorizePkceUrl({ clientId, redirectUri, scopes }: AuthorizationCodeClient, options?: Options): Promise<string>;
-    /**
-     * Patch: Get the stored PKCE code verifier
-     */
-    getCodeVerifier(): string | null;
-    /**
-     * Patch: called custom implementation this.__getToken_custom instead of this.__getToken
-     * Extended to support additional scopes
-     */
-    getToken(request: Corti.AuthGetTokenRequest & {
+export declare namespace CortiAuth {
+    /** Auth (clientId/clientSecret or token) is optional; credentials can be passed to getToken() instead. */
+    type Options = Omit<AuthClient.Options, "clientId" | "clientSecret" | "token" | "environment"> & Partial<OAuthAuthProvider.ClientCredentials> & Partial<OAuthAuthProvider.TokenOverride> & {
+        environment: Environment;
+    };
+    /** Optional scopes on getToken request. */
+    interface GetTokenRequest extends Corti.OAuthTokenRequest {
         scopes?: string[];
-    }, requestOptions?: FernAuth.RequestOptions): core.HttpResponsePromise<Corti.GetTokenResponse>;
-    /**
-     * Patch: added method to get Authorization URL for Authorization code flow and PKCE flow
-     */
-    authorizeURL({ clientId, redirectUri, codeChallenge, scopes }: AuthorizationCodeClient, options?: Options): Promise<string>;
+    }
+    /** ROPC (resource owner password credentials) request for getRopcFlowToken. */
+    interface GetRopcFlowTokenRequest {
+        clientId: string;
+        username: string;
+        password: string;
+        scopes?: string[];
+    }
+    /** Refresh token request for refreshToken. */
+    interface RefreshTokenRequest {
+        clientId: string;
+        refreshToken: string;
+        clientSecret?: string;
+        scopes?: string[];
+    }
+    /** Authorization code grant request for getCodeFlowToken. */
+    interface GetCodeFlowTokenRequest {
+        clientId: string;
+        clientSecret: string;
+        redirectUri: string;
+        code: string;
+        scopes?: string[];
+    }
+    /** PKCE grant request for getPkceFlowToken. codeVerifier is optional — if omitted, reads from localStorage. */
+    interface GetPkceFlowTokenRequest {
+        clientId: string;
+        redirectUri: string;
+        code: string;
+        codeVerifier?: string;
+        scopes?: string[];
+    }
+    /** Parameters for authorizeUrl — builds the Keycloak authorization endpoint URL. */
+    interface AuthorizationCodeClient {
+        clientId: string;
+        redirectUri: string;
+        codeChallenge?: string;
+        scopes?: string[];
+    }
+    /** Parameters for authorizePkceUrl — like AuthorizationCodeClient but without codeChallenge (generated internally). */
+    interface PkceClient {
+        clientId: string;
+        redirectUri: string;
+        scopes?: string[];
+        codeVerifier?: string;
+    }
+}
+export declare class CortiAuth extends AuthClient {
+    /** No-op auth provider so super.token() does not trigger OAuth refresh. When auth is omitted, a dummy token is passed so the base constructor does not throw. */
+    constructor(options: CortiAuth.Options);
     /**
-     * Patch: calls __getToken_custom with additional fields to support Authorization code flow
+     * Exchange credentials for a short-lived access token using the tenant token endpoint (client_credentials).
+     * Resolves tenant from client options. Supports optional scopes (openid is always included).
+     *
+     * @param request - Client credentials and optional scopes
+     * @param requestOptions - Request-specific configuration
+     *
+     * @throws {@link Corti.BadRequestError}
+     * @throws {@link Corti.UnauthorizedError}
+     *
+     * @example
+     *     const response = await auth.getToken({
+     *         clientId: "client_id",
+     *         clientSecret: "client_secret",
+     *         scopes: ["profile"]
+     *     });
      */
-    getCodeFlowToken(request: AuthorizationCode, requestOptions?: FernAuth.RequestOptions): core.HttpResponsePromise<Corti.GetTokenResponse>;
+    getToken(request: CortiAuth.GetTokenRequest, requestOptions?: AuthClient.RequestOptions): core.HttpResponsePromise<Corti.AuthTokenResponse>;
+    private _getTokenWithTenant;
+    /** Exchange username/password for access token via ROPC (resource owner password credentials). */
+    getRopcFlowToken(request: CortiAuth.GetRopcFlowTokenRequest, requestOptions?: AuthClient.RequestOptions): core.HttpResponsePromise<Corti.AuthTokenResponse>;
     /**
-     * Patch: PKCE-specific method
+     * Exchange a refresh token for a new access token (refresh_token grant).
+     * Resolves tenant from client options.
+     *
+     * @param request - Client ID, refresh token, and optional scopes
+     * @param requestOptions - Request-specific configuration
+     *
+     * @throws {@link Corti.BadRequestError}
+     * @throws {@link Corti.UnauthorizedError}
+     *
+     * @example
+     *     const response = await auth.refreshToken({
+     *         clientId: "client_id",
+     *         refreshToken: "refresh_token",
+     *     });
      */
-    getPkceFlowToken(request: AuthorizationPkce, requestOptions?: FernAuth.RequestOptions): core.HttpResponsePromise<Corti.GetTokenResponse>;
+    refreshToken(request: CortiAuth.RefreshTokenRequest, requestOptions?: AuthClient.RequestOptions): core.HttpResponsePromise<Corti.AuthTokenResponse>;
+    /** Exchange an authorization code for an access token (authorization_code grant). */
+    getCodeFlowToken(request: CortiAuth.GetCodeFlowTokenRequest, requestOptions?: AuthClient.RequestOptions): core.HttpResponsePromise<Corti.AuthTokenResponse>;
     /**
-     * Patch: ROPC-specific method
+     * Exchange a PKCE authorization code for an access token (authorization_code grant with code_verifier).
+     * If codeVerifier is omitted, it is read from localStorage (set by authorizePkceUrl).
      */
-    getRopcFlowToken(request: AuthorizationRopcServer, requestOptions?: FernAuth.RequestOptions): core.HttpResponsePromise<Corti.GetTokenResponse>;
+    getPkceFlowToken(request: CortiAuth.GetPkceFlowTokenRequest, requestOptions?: AuthClient.RequestOptions): core.HttpResponsePromise<Corti.AuthTokenResponse>;
     /**
-     * Patch: copy of this.__getToken with patches
+     * Build the Keycloak authorization endpoint URL for the PKCE flow.
+     * Generates a code verifier if not provided, stores it in localStorage, and computes the challenge.
+     * In a browser environment, redirects to the URL unless skipRedirect is true.
      */
-    private __getToken_custom;
+    authorizePkceUrl({ clientId, redirectUri, scopes, codeVerifier }: CortiAuth.PkceClient, options?: Options): Promise<string>;
+    /** Read the PKCE code verifier stored in localStorage by authorizePkceUrl. Returns null if not found. */
+    static getCodeVerifier(): string | null;
     /**
-     * Patch: calls __getToken_custom with additional fields to support Refresh token flow
+     * Build the Keycloak authorization endpoint URL for the authorization code flow.
+     * In a browser environment, redirects to the URL unless skipRedirect is true.
+     * In a server environment (no window), always returns the URL string.
+     *
+     * @param client - clientId, redirectUri, and optional codeChallenge/scopes
+     * @param options - { skipRedirect?: boolean }
      */
-    refreshToken(request: AuthorizationRefreshServer, requestOptions?: FernAuth.RequestOptions): core.HttpResponsePromise<Corti.GetTokenResponse>;
+    authorizeUrl({ clientId, redirectUri, codeChallenge, scopes }: CortiAuth.AuthorizationCodeClient, options?: Options): Promise<string>;
 }
 export {};