@brokerize/client 1.4.0 → 1.6.0

package/dist/apiCtx.js

@@ -1,7 +1,7 @@
 /* Import/Export the DOM parts we rely on. Those are partial copies from the official TypeScript DOM library definitions (https://github.com/microsoft/TypeScript/blob/master/lib/lib.dom.d.ts),
    but reduced to the parts actually used by bg-trading. */
-import { BrokerizeError } from ".";
-import { Configuration } from "./swagger";
+import { BrokerizeError } from "./index.js";
+import { Configuration } from "./swagger/index.js";
 export function createConfiguration(cfg) {
     if (!cfg.clientId) {
         throw new Error("You must configure a clientId to use the brokerize API.");

package/dist/authorizedApiContext.js

@@ -1,9 +1,9 @@
 import { Subject } from "rxjs";
-import { createConfiguration } from "./apiCtx";
-import { BrokerizeError } from "./errors";
-import { createPollingSubscription } from "./pollingSubscription";
-import * as openApiClient from "./swagger";
-import { BrokerizeWebSocketClientImpl, } from "./websocketClient";
+import { createConfiguration } from "./apiCtx.js";
+import { BrokerizeError } from "./errors.js";
+import { createPollingSubscription } from "./pollingSubscription.js";
+import * as openApiClient from "./swagger/index.js";
+import { BrokerizeWebSocketClientImpl, } from "./websocketClient.js";
 export class AuthorizedApiContext {
     constructor(cfg, auth, wsClient) {
         this._isDestroyed = false;

package/dist/cjs/apiCtx.d.ts

@@ -0,0 +1,75 @@
+import { Models, TokenRefreshCallback } from ".";
+import { WhatWgFetch } from "./dependencyDefinitions/fetch";
+import { WebSocket } from "./dependencyDefinitions/webSocket";
+import { Configuration } from "./swagger";
+export interface BrokerizeConfig {
+    fetch?: WhatWgFetch;
+    createAbortController?: () => AbortController;
+    createWebSocket?: (url?: string, protocol?: string | string[]) => WebSocket;
+    /**
+     * Path to the API, e.g. https://api-preview.brokerize.com
+     */
+    basePath?: string;
+    /**
+     * Path to the crypto trading API (c.f. tradingViaCryptoService), e.g. https://crypto-service-api.com
+     */
+    basePathCryptoService?: string;
+    clientId: string;
+    /**
+     * The AWS cognito configuration, if the application is supposed to be used with brokerize accounts.
+     */
+    cognito?: CognitoConfig;
+}
+export type AuthContextConfiguration = GuestAuthContextConfiguration | RegisteredUserAuthContextConfiguration;
+export type RegisteredUserAuthContextConfiguration = {
+    type: "registered";
+    username: string;
+    tokens: TokenSet;
+};
+export type TokenSet = {
+    idToken: string;
+    refreshToken: string;
+    expiresAt: number;
+};
+export interface GuestAuthContextConfiguration {
+    type: "guest";
+    /**
+     * @deprecated use tokens instead
+     */
+    idToken: string;
+    tokens: {
+        updatedAt: number;
+        response: Models.CreateGuestUserResponse;
+    };
+}
+export interface Auth {
+    getToken: () => Promise<{
+        idToken: string;
+    }>;
+}
+export declare function createConfiguration(cfg: BrokerizeConfig): Configuration;
+export declare function createAuth({ authCfg, cfg, options, tokenRefreshCallback, }: {
+    authCfg: AuthContextConfiguration;
+    cfg: BrokerizeConfig;
+    options?: AuthorizedApiContextOptions;
+    tokenRefreshCallback?: TokenRefreshCallback;
+}): Auth;
+export type CognitoConfig = {
+    poolConfig: CognitoPoolConfig;
+    cognitoFacade: CognitoFacade;
+};
+export type CognitoPoolConfig = {
+    UserPoolId: string;
+    ClientId: string;
+    Endpoint?: string | null;
+};
+export type CognitoFacade = {
+    createSession: (cognitoPoolConfig: CognitoPoolConfig, authCfg: RegisteredUserAuthContextConfiguration) => {
+        getToken: () => Promise<{
+            idToken: string;
+        }>;
+    };
+};
+export type AuthorizedApiContextOptions = {
+    cognitoFacade?: CognitoFacade;
+};

package/dist/cjs/apiCtx.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAuth = exports.createConfiguration = void 0;
+/* Import/Export the DOM parts we rely on. Those are partial copies from the official TypeScript DOM library definitions (https://github.com/microsoft/TypeScript/blob/master/lib/lib.dom.d.ts),
+   but reduced to the parts actually used by bg-trading. */
+const _1 = require(".");
+const swagger_1 = require("./swagger");
+function createConfiguration(cfg) {
+    if (!cfg.clientId) {
+        throw new Error("You must configure a clientId to use the brokerize API.");
+    }
+    return new swagger_1.Configuration({
+        fetchApi: cfg.fetch,
+        basePath: cfg.basePath,
+    });
+}
+exports.createConfiguration = createConfiguration;
+function createAuth({ authCfg, cfg, options, tokenRefreshCallback, }) {
+    var _a;
+    if (authCfg.type == "guest") {
+        const guestAuthCfg = JSON.parse(JSON.stringify(authCfg)); // clone it
+        return {
+            async getToken() {
+                if (guestAuthCfg.tokens) {
+                    let expiresIn = guestAuthCfg.tokens.response.expiresIn;
+                    if (expiresIn == null) {
+                        // eslint-disable-next-line no-console
+                        console.log("[brokerize client] expiresIn is unexpectedly nullish. assuming 300 seconds");
+                        expiresIn = 300;
+                    }
+                    /* modern tokens */
+                    const tokenExpiresAt = guestAuthCfg.tokens.updatedAt + expiresIn * 1000 - 10000;
+                    const needsRefresh = Date.now() > tokenExpiresAt;
+                    if (needsRefresh && guestAuthCfg.tokens.response.refreshToken) {
+                        if (!cfg.fetch) {
+                            throw new Error("Invalid cfg: fetch is required for refreshing tokens.");
+                        }
+                        const response = await fetch(cfg.basePath + "/user/token", {
+                            method: "POST",
+                            headers: {
+                                "x-brkrz-client-id": cfg.clientId,
+                                "Content-Type": "application/x-www-form-urlencoded",
+                            },
+                            // XXX some runtimes do not have URLSearchParams, so just produce the body in the old-fashioned way
+                            body: `grant_type=refresh_token&refresh_token=${encodeURIComponent(guestAuthCfg.tokens.response.refreshToken)}`,
+                        });
+                        if (!response.ok) {
+                            throw new _1.BrokerizeError(401, {
+                                msg: "The token could not be refreshed. Please log in again.",
+                                code: "AUTH",
+                            });
+                        }
+                        const responseJson = (await response.json());
+                        guestAuthCfg.idToken = responseJson.access_token;
+                        // replace the original object
+                        guestAuthCfg.tokens = {
+                            updatedAt: Date.now(),
+                            response: {
+                                accessToken: responseJson.access_token,
+                                refreshToken: responseJson.refresh_token,
+                                expiresIn: responseJson.expires_in,
+                                tokenType: responseJson.token_type,
+                                refreshTokenExpiresIn: responseJson.refresh_token_expires_in,
+                                idToken: responseJson.access_token,
+                                refreshTokenWithoutTradingsession: responseJson.refresh_token_without_tradingsession,
+                                refreshTokenWithoutTradingsessionExpiresIn: responseJson.refresh_token_without_tradingsession_expires_in,
+                            },
+                        };
+                        if (tokenRefreshCallback) {
+                            tokenRefreshCallback(guestAuthCfg);
+                        }
+                        return { idToken: responseJson.access_token };
+                    }
+                }
+                return { idToken: guestAuthCfg.idToken };
+            },
+        };
+    }
+    else if (authCfg.type == "registered") {
+        if (!cfg.cognito) {
+            throw new Error("Trying to initialize createAuth for cognito, but no cognito config present in BrokerizeConfig.");
+        }
+        if (!(options === null || options === void 0 ? void 0 : options.cognitoFacade)) {
+            throw new Error("Trying to initialize createAuth for cognito, but access to the cognito library was not provided in the options.");
+        }
+        const session = options.cognitoFacade.createSession((_a = cfg.cognito) === null || _a === void 0 ? void 0 : _a.poolConfig, authCfg);
+        return {
+            async getToken() {
+                return session.getToken();
+            },
+        };
+    }
+    else {
+        throw new Error("Unsupported auth config.");
+    }
+}
+exports.createAuth = createAuth;

package/dist/cjs/authorizedApiContext.d.ts

@@ -0,0 +1,149 @@
+import { Auth, BrokerizeConfig } from "./apiCtx";
+import * as openApiClient from "./swagger";
+import { AddSessionParams, ConfirmOAuthParams, CreateTradeChallengeRequest, CreateTradeRequest, DeleteDemoAccountRequest, DemoAccountSettings, GenericTable, GetCostEstimationParams, GetQuoteRequest, OrderChanges, PrepareOAuthRedirectParams, PrepareTradeRequest } from "./swagger";
+import { BrokerizeWebSocketClient, Callback, Subscription } from "./websocketClient";
+export declare class AuthorizedApiContext {
+    private _isDestroyed;
+    private _childContexts;
+    private readonly _cfg;
+    private readonly _auth;
+    private readonly _demoBrokerApi;
+    private readonly _tradeApi;
+    private readonly _tradeApiCryptoService;
+    private readonly _abortController;
+    private readonly _metaApi;
+    private readonly _sessionApi;
+    private readonly _tradeDraftApi;
+    private readonly _orderApi;
+    private readonly _orderApiCryptoService;
+    private readonly _logoutSubject;
+    private readonly _wsClient;
+    private readonly _cache;
+    private readonly _exportApi;
+    private readonly _adminApi;
+    private readonly _userApi;
+    private readonly _securitiesApi;
+    private readonly _portfolioApi;
+    private readonly _decoupledOperationsApi;
+    constructor(cfg: BrokerizeConfig, auth: Auth, wsClient?: BrokerizeWebSocketClient);
+    createChildContext(): AuthorizedApiContext;
+    private _initRequestInit;
+    getBrokers(): Promise<openApiClient.GetBrokersResponse>;
+    getTradeDrafts(params: openApiClient.GetTradeDraftsRequest): Promise<openApiClient.GetActiveTradeDraftsResponse>;
+    createTradeDraft(params: openApiClient.CreateTradeDraftsRequest): Promise<openApiClient.CreateTradeDrafts200Response>;
+    updateTradeDraft(params: openApiClient.UpdateTradeDraftRequest): Promise<void>;
+    deactivateTradeDraft(params: openApiClient.DeactivateTradeDraftRequest): Promise<void>;
+    deleteTradeDraft(params: openApiClient.DeleteTradeDraftRequest): Promise<void>;
+    getLegalTerms(): Promise<openApiClient.LegalTermsResponse>;
+    getExchanges(): Promise<openApiClient.ExchangesResponse>;
+    addSession(params: AddSessionParams): Promise<openApiClient.LoginResponse>;
+    getSessions(): Promise<openApiClient.SessionResponse>;
+    createDemoAccount(demoAccountSettings?: DemoAccountSettings): Promise<openApiClient.CreatedResponseBody>;
+    getAccessTokens(): Promise<openApiClient.GetAccessTokensResponse>;
+    createAccessToken(params: openApiClient.CreateAccessTokenParams): Promise<openApiClient.AccessTokenResult>;
+    revokeAccessToken(accessTokenId: string): Promise<void>;
+    getAcessTokenAvailablePermissions(): Promise<openApiClient.GetAcessTokenAvailablePermissions200Response>;
+    getDemoAccounts(): Promise<openApiClient.DemoAccountsResponse>;
+    deleteDemoAccount(del: DeleteDemoAccountRequest): Promise<openApiClient.OkResponseBody>;
+    getOrder(orderId: string): Promise<openApiClient.GetOrderResponse>;
+    createCancelOrderChallenge(req: openApiClient.CreateCancelOrderChallengeRequest): Promise<openApiClient.Challenge>;
+    cancelOrder(req: openApiClient.CancelOrderRequest, viaCryptoService?: boolean): Promise<openApiClient.CancelOrderResponse>;
+    createChangeOrderChallenge(req: openApiClient.CreateChangeOrderChallengeRequest): Promise<openApiClient.Challenge>;
+    changeOrder(req: openApiClient.ChangeOrderRequest, viaCryptoService?: boolean): Promise<openApiClient.ChangeOrderResponse>;
+    getPortfolios(): Promise<openApiClient.PortfoliosResponse>;
+    renamePortfolio(portfolioId: string, newPortfolioName: string): Promise<void>;
+    deletePortfolio(portfolioId: string): Promise<openApiClient.OkResponseBody>;
+    getPortfolioQuotes(portfolioId: string): Promise<openApiClient.GetPortfolioQuotesResponse>;
+    getPortfolioPositions(portfolioId: string): Promise<openApiClient.GetPortfolioPositionsResponse>;
+    getPortfolioOrders(req: openApiClient.GetPortfolioOrdersRequest): Promise<openApiClient.GetPortfolioOrdersResponse>;
+    getPortfolioTrades(req: openApiClient.GetPortfolioTradesRequest): Promise<openApiClient.GetPortfolioTradesResponse>;
+    getPortfolioCalendar(req: openApiClient.GetPortfolioCalendarRequest): Promise<openApiClient.GetPortfolioCalendarResponse>;
+    getPortfolioTradeWarnings(req: openApiClient.GetPortfolioTradeWarningsRequest): Promise<openApiClient.TradeWarning[]>;
+    getPortfolioTradeStatistics(req: openApiClient.GetPortfolioTradeStatisticsRequest): Promise<openApiClient.GetPortfolioTradeStatisticsResponse>;
+    getAuthInfo(portfolioId: string): Promise<openApiClient.GetAuthInfoResponse>;
+    addSessionCompleteChallenge(req: openApiClient.AddSessionCompleteChallengeRequest): Promise<openApiClient.LoginResponseReady>;
+    createSessionTanChallenge(req: openApiClient.CreateSessionTanChallengeRequest): Promise<openApiClient.Challenge>;
+    enableSessionTan(req: openApiClient.EnableSessionTanRequest): Promise<openApiClient.EnableSessionTanResponse>;
+    endSessionTan(sessionId: string): Promise<openApiClient.EndSessionTanResponse>;
+    getDecoupledOperationStatus(req: openApiClient.GetDecoupledOperationStatusRequest): Promise<openApiClient.DecoupledOperationStatus>;
+    cancelDecoupledOperation(req: openApiClient.CancelDecoupledOperationRequest): Promise<void>;
+    triggerSessionSync(sessionId: string): Promise<openApiClient.OkResponseBody>;
+    triggerDemoSessionSyncError(sessionId: string): Promise<openApiClient.OkResponseBody>;
+    logoutSession(sessionId: string): Promise<openApiClient.LogoutOkResponseBody>;
+    getUser(): Promise<openApiClient.GetUserResponse>;
+    deleteGuestUser(): Promise<void>;
+    prepareTrade(req: PrepareTradeRequest): Promise<openApiClient.PrepareTradeResponse>;
+    createTrade(req: CreateTradeRequest, viaCryptoService?: boolean): Promise<openApiClient.CreateTradeResponse>;
+    createTradeChallenge(req: CreateTradeChallengeRequest): Promise<openApiClient.Challenge>;
+    getCostEstimation(p: GetCostEstimationParams): Promise<openApiClient.OrderCostEstimation>;
+    getChangeOrderCostEstimation(orderId: string, changes: OrderChanges): Promise<openApiClient.OrderCostEstimation>;
+    getQuote(p: GetQuoteRequest): Promise<openApiClient.GetQuoteResponse>;
+    prepareOAuthRedirect(p: PrepareOAuthRedirectParams): Promise<openApiClient.PrepareOAuthRedirectResponse>;
+    confirmOAuth(p: ConfirmOAuthParams): Promise<openApiClient.ConfirmOAuthResponse>;
+    getSecurityDetailedInfo(token: string): Promise<openApiClient.GenericTable>;
+    renderGenericTablePdf(table: GenericTable): Promise<Blob>;
+    getMyClients(): Promise<openApiClient.ClientsResponseInner[]>;
+    createClient(): Promise<openApiClient.CreateClient200Response>;
+    deleteClient(clientId: string): Promise<void>;
+    addClientOrigin(clientId: string, origin: string): Promise<void>;
+    removeClientOrigin(clientId: string, origin: string): Promise<void>;
+    addClientOAuthReturnToUrl(clientId: string, url: string): Promise<void>;
+    removeClientOAuthReturnToUrl(clientId: string, url: string): Promise<void>;
+    setClientConfig(clientId: string, config: openApiClient.ClientConfigUpdate): Promise<void>;
+    getOrderReport(opts: {
+        from: string;
+        to: string;
+        clientIds?: string[];
+        onlyExecutedOrders?: boolean;
+        format?: "xlsx" | "csv";
+    }): Promise<{
+        filename: string | null;
+        data: Promise<Blob>;
+        contentType: string | null;
+    }>;
+    getSecurityQuotes(opts: {
+        securityQuotesToken: string;
+    }): Promise<openApiClient.SecurityQuotesResponse>;
+    getSecurityQuotesMeta(securityQuotesToken: string): Promise<openApiClient.SecurityQuotesMeta>;
+    getRecoveryPhrases(): Promise<openApiClient.GetRecoveryPhrasesResponse>;
+    createRecoveryPhrase(opts: {
+        name: string;
+    }): Promise<openApiClient.CreateRecoveryPhraseResult>;
+    deleteRecoveryPhrase(recoveryPhraseId: string): Promise<void>;
+    /**
+     * Subscribe to security quotes. Note that this currently uses polling to load the quotes from the
+     * API. This will be replaced with a websocket-based solution in the future, but we can keep this
+     * interface upwards-compatible.
+     *
+     * If an error occurs during the polling, the callback will receive the error and the subscription
+     * ends, which means the application should handle the error and possibly re-subscribe later.
+     *
+     * @param securityQuotesToken the `securityQuotesToken` to subscribe to
+     * @param callback a callback that will be called with the quotes
+     * @returns a subscription object with a function `unsubscribe` that can be used to stop polling
+     */
+    subscribeQuotes(securityQuotesToken: string, callback: Callback<openApiClient.SecurityQuotesResponse | undefined>): {
+        unsubscribe(): void;
+    };
+    /**
+     * Subscribe to the available order intents based on a `PreparedTrade`. Note that this currently uses polling to load the quotes from the
+     * API. This will be replaced with a websocket-based solution in the future, but we can keep this
+     * interface upwards-compatible.
+     *
+     * If an error occurs during the polling, the callback will receive the error and the subscription
+     * ends, which means the application should handle the error and possibly re-subscribe later.
+     *
+     * @param preparedTrade The `PreparedTrade` as retrived by `PrepareTrade`.
+     * @param callback a callback that will be called with the available order intents
+     *
+     * @returns a subscription object with a function `unsubscribe` that can be used to stop polling
+     */
+    subscribeAvailableOrderIntents(preparedTrade: openApiClient.PreparedTrade, callback: Callback<openApiClient.OrderIntentAvailability | undefined>): {
+        unsubscribe(): void;
+    };
+    private _initInternalWebSocketClient;
+    createWebSocketClient(): BrokerizeWebSocketClient;
+    destroy(): void;
+    subscribeLogout(callback: Callback): Subscription;
+}
+export declare function getWebSocketURLByBasePath(basePath: string): string;