@tastytrade/api 0.0.1

package/dist/services/transactions-service.js

@@ -0,0 +1,91 @@
+"use strict";
+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());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var response_util_1 = __importDefault(require("../utils/response-util"));
+var TransactionsService = /** @class */ (function () {
+    function TransactionsService(httpClient) {
+        this.httpClient = httpClient;
+    }
+    //Accounts:  Operations about Accounts
+    TransactionsService.prototype.getTransaction = function (accountNumber, id) {
+        return __awaiter(this, void 0, void 0, function () {
+            var symbolData;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.httpClient.getData("/accounts/".concat(accountNumber, "/transactions/").concat(id), {}, {})];
+                    case 1:
+                        symbolData = (_a.sent());
+                        return [2 /*return*/, (0, response_util_1.default)(symbolData)];
+                }
+            });
+        });
+    };
+    TransactionsService.prototype.getTotalFees = function (accountNumber) {
+        return __awaiter(this, void 0, void 0, function () {
+            var totalFees;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.httpClient.getData("/accounts/".concat(accountNumber, "/transactions/total-fees"), {}, {})];
+                    case 1:
+                        totalFees = (_a.sent());
+                        return [2 /*return*/, (0, response_util_1.default)(totalFees)];
+                }
+            });
+        });
+    };
+    //Transactions:  Operations about transactions
+    TransactionsService.prototype.getAccountTransactions = function (accountNumber, queryParams) {
+        if (queryParams === void 0) { queryParams = {}; }
+        return __awaiter(this, void 0, void 0, function () {
+            var accountTransactions;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.httpClient.getData("/accounts/".concat(accountNumber, "/transactions"), {}, queryParams)];
+                    case 1:
+                        accountTransactions = (_a.sent());
+                        return [2 /*return*/, (0, response_util_1.default)(accountTransactions)];
+                }
+            });
+        });
+    };
+    return TransactionsService;
+}());
+exports.default = TransactionsService;

package/dist/services/watchlists-service.d.ts

@@ -0,0 +1,14 @@
+import TastytradeHttpClient from "./tastytrade-http-client";
+export default class WatchlistsService {
+    private httpClient;
+    constructor(httpClient: TastytradeHttpClient);
+    getPairsWatchlists(): Promise<any>;
+    getPairsWatchlist(pairsWatchlistName: string): Promise<any>;
+    getPublicWatchlists(countsOnly?: boolean): Promise<any>;
+    getPublicWatchlist(watchlistName: string): Promise<any>;
+    createAccountWatchlist(watchlist: object): Promise<any>;
+    getAllWatchlists(): Promise<any>;
+    replaceWatchlist(watchlistName: string, replacementWatchlist: object): Promise<any>;
+    deleteWatchlist(watchlistName: string): Promise<any>;
+    getSingleWatchlist(watchlistName: string): Promise<any>;
+}

package/dist/services/watchlists-service.js

@@ -0,0 +1,170 @@
+"use strict";
+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());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var response_util_1 = __importDefault(require("../utils/response-util"));
+var WatchlistsService = /** @class */ (function () {
+    function WatchlistsService(httpClient) {
+        this.httpClient = httpClient;
+    }
+    //Pairs Watchlists: Allows an API client to fetch pairs watchlists.
+    WatchlistsService.prototype.getPairsWatchlists = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var pairsWatchlists;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.httpClient.getData("/pairs-watchlists", {}, {})];
+                    case 1:
+                        pairsWatchlists = _a.sent();
+                        return [2 /*return*/, (0, response_util_1.default)(pairsWatchlists)];
+                }
+            });
+        });
+    };
+    WatchlistsService.prototype.getPairsWatchlist = function (pairsWatchlistName) {
+        return __awaiter(this, void 0, void 0, function () {
+            var pairsWatchlist;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.httpClient.getData("/pairs-watchlists/".concat(pairsWatchlistName), {}, {})];
+                    case 1:
+                        pairsWatchlist = _a.sent();
+                        return [2 /*return*/, (0, response_util_1.default)(pairsWatchlist)];
+                }
+            });
+        });
+    };
+    //Public Watchlists: Allows an API client to fetch tastyworks watchlists.
+    WatchlistsService.prototype.getPublicWatchlists = function (countsOnly) {
+        if (countsOnly === void 0) { countsOnly = false; }
+        return __awaiter(this, void 0, void 0, function () {
+            var publicWatchlists;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.httpClient.getData("/public-watchlists", {}, { 'counts-only': countsOnly })];
+                    case 1:
+                        publicWatchlists = _a.sent();
+                        return [2 /*return*/, (0, response_util_1.default)(publicWatchlists)];
+                }
+            });
+        });
+    };
+    WatchlistsService.prototype.getPublicWatchlist = function (watchlistName) {
+        return __awaiter(this, void 0, void 0, function () {
+            var publicWatchlist;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.httpClient.getData("/public-watchlists/".concat(watchlistName), {}, {})];
+                    case 1:
+                        publicWatchlist = _a.sent();
+                        return [2 /*return*/, (0, response_util_1.default)(publicWatchlist)];
+                }
+            });
+        });
+    };
+    //User Watchlists: Allows an API client to fetch a user's watchlists.
+    WatchlistsService.prototype.createAccountWatchlist = function (watchlist) {
+        return __awaiter(this, void 0, void 0, function () {
+            var accountWatchlist;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.httpClient.postData("/watchlists", watchlist, {})];
+                    case 1:
+                        accountWatchlist = _a.sent();
+                        return [2 /*return*/, (0, response_util_1.default)(accountWatchlist)];
+                }
+            });
+        });
+    };
+    WatchlistsService.prototype.getAllWatchlists = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var allWatchlists;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.httpClient.getData("/watchlists", {}, {})];
+                    case 1:
+                        allWatchlists = _a.sent();
+                        return [2 /*return*/, (0, response_util_1.default)(allWatchlists)];
+                }
+            });
+        });
+    };
+    WatchlistsService.prototype.replaceWatchlist = function (watchlistName, replacementWatchlist) {
+        return __awaiter(this, void 0, void 0, function () {
+            var watchlist;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.httpClient.putData("/watchlists/".concat(watchlistName), replacementWatchlist, {})];
+                    case 1:
+                        watchlist = _a.sent();
+                        return [2 /*return*/, (0, response_util_1.default)(watchlist)];
+                }
+            });
+        });
+    };
+    WatchlistsService.prototype.deleteWatchlist = function (watchlistName) {
+        return __awaiter(this, void 0, void 0, function () {
+            var watchlist;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.httpClient.deleteData("/watchlists/".concat(watchlistName), {})];
+                    case 1:
+                        watchlist = _a.sent();
+                        return [2 /*return*/, (0, response_util_1.default)(watchlist)];
+                }
+            });
+        });
+    };
+    WatchlistsService.prototype.getSingleWatchlist = function (watchlistName) {
+        return __awaiter(this, void 0, void 0, function () {
+            var singleWatchlist;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.httpClient.getData("/watchlists/".concat(watchlistName), {}, {})];
+                    case 1:
+                        singleWatchlist = _a.sent();
+                        return [2 /*return*/, (0, response_util_1.default)(singleWatchlist)];
+                }
+            });
+        });
+    };
+    return WatchlistsService;
+}());
+exports.default = WatchlistsService;

package/dist/tastytrade-api.d.ts

@@ -0,0 +1,40 @@
+import TastytradeHttpClient from "./services/tastytrade-http-client";
+import { AccountStreamer, STREAMER_STATE, Disposer, StreamerStateObserver } from './account-streamer';
+import QuoteStreamer from "./quote-streamer";
+import SessionService from "./services/session-service";
+import AccountStatusService from "./services/account-status-service";
+import AccountsAndCustomersService from "./services/accounts-and-customers-service";
+import BalancesAndPositionsService from "./services/balances-and-positions-service";
+import InstrumentsService from "./services/instruments-service";
+import MarginRequirementsService from "./services/margin-requirements-service";
+import MarketMetricsService from "./services/market-metrics-service";
+import NetLiquidatingValueHistoryService from "./services/net-liquidating-value-history-service";
+import OrderService from "./services/orders-service";
+import RiskParametersService from "./services/risk-parameters-service";
+import SymbolSearchService from "./services/symbol-search-service";
+import TransactionsService from "./services/transactions-service";
+import WatchlistsService from "./services/watchlists-service";
+import TastytradeSession from "./models/tastytrade-session";
+export default class TastytradeClient {
+    readonly baseUrl: string;
+    readonly accountStreamerUrl: string;
+    readonly httpClient: TastytradeHttpClient;
+    readonly accountStreamer: AccountStreamer;
+    readonly sessionService: SessionService;
+    readonly accountStatusService: AccountStatusService;
+    readonly accountsAndCustomersService: AccountsAndCustomersService;
+    readonly balancesAndPositionsService: BalancesAndPositionsService;
+    readonly instrumentsService: InstrumentsService;
+    readonly marginRequirementsService: MarginRequirementsService;
+    readonly marketMetricsService: MarketMetricsService;
+    readonly netLiquidatingValueHistoryService: NetLiquidatingValueHistoryService;
+    readonly orderService: OrderService;
+    readonly riskParametersService: RiskParametersService;
+    readonly symbolSearchService: SymbolSearchService;
+    readonly transactionsService: TransactionsService;
+    readonly watchlistsService: WatchlistsService;
+    constructor(baseUrl: string, accountStreamerUrl: string);
+    get session(): TastytradeSession;
+}
+export { QuoteStreamer };
+export { AccountStreamer, STREAMER_STATE, Disposer, StreamerStateObserver };

package/dist/tastytrade-api.js

@@ -0,0 +1,56 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STREAMER_STATE = exports.AccountStreamer = exports.QuoteStreamer = void 0;
+var tastytrade_http_client_1 = __importDefault(require("./services/tastytrade-http-client"));
+var account_streamer_1 = require("./account-streamer");
+Object.defineProperty(exports, "AccountStreamer", { enumerable: true, get: function () { return account_streamer_1.AccountStreamer; } });
+Object.defineProperty(exports, "STREAMER_STATE", { enumerable: true, get: function () { return account_streamer_1.STREAMER_STATE; } });
+var quote_streamer_1 = __importDefault(require("./quote-streamer"));
+exports.QuoteStreamer = quote_streamer_1.default;
+//Services:
+var session_service_1 = __importDefault(require("./services/session-service"));
+var account_status_service_1 = __importDefault(require("./services/account-status-service"));
+var accounts_and_customers_service_1 = __importDefault(require("./services/accounts-and-customers-service"));
+var balances_and_positions_service_1 = __importDefault(require("./services/balances-and-positions-service"));
+var instruments_service_1 = __importDefault(require("./services/instruments-service"));
+var margin_requirements_service_1 = __importDefault(require("./services/margin-requirements-service"));
+var market_metrics_service_1 = __importDefault(require("./services/market-metrics-service"));
+var net_liquidating_value_history_service_1 = __importDefault(require("./services/net-liquidating-value-history-service"));
+var orders_service_1 = __importDefault(require("./services/orders-service"));
+var risk_parameters_service_1 = __importDefault(require("./services/risk-parameters-service"));
+var symbol_search_service_1 = __importDefault(require("./services/symbol-search-service"));
+var transactions_service_1 = __importDefault(require("./services/transactions-service"));
+var watchlists_service_1 = __importDefault(require("./services/watchlists-service"));
+var TastytradeClient = /** @class */ (function () {
+    function TastytradeClient(baseUrl, accountStreamerUrl) {
+        this.baseUrl = baseUrl;
+        this.accountStreamerUrl = accountStreamerUrl;
+        this.httpClient = new tastytrade_http_client_1.default(baseUrl);
+        this.accountStreamer = new account_streamer_1.AccountStreamer(accountStreamerUrl, this.session);
+        this.sessionService = new session_service_1.default(this.httpClient);
+        this.accountStatusService = new account_status_service_1.default(this.httpClient);
+        this.accountsAndCustomersService = new accounts_and_customers_service_1.default(this.httpClient);
+        this.balancesAndPositionsService = new balances_and_positions_service_1.default(this.httpClient);
+        this.instrumentsService = new instruments_service_1.default(this.httpClient);
+        this.marginRequirementsService = new margin_requirements_service_1.default(this.httpClient);
+        this.marketMetricsService = new market_metrics_service_1.default(this.httpClient);
+        this.netLiquidatingValueHistoryService = new net_liquidating_value_history_service_1.default(this.httpClient);
+        this.orderService = new orders_service_1.default(this.httpClient);
+        this.riskParametersService = new risk_parameters_service_1.default(this.httpClient);
+        this.symbolSearchService = new symbol_search_service_1.default(this.httpClient);
+        this.transactionsService = new transactions_service_1.default(this.httpClient);
+        this.watchlistsService = new watchlists_service_1.default(this.httpClient);
+    }
+    Object.defineProperty(TastytradeClient.prototype, "session", {
+        get: function () {
+            return this.httpClient.session;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return TastytradeClient;
+}());
+exports.default = TastytradeClient;

package/dist/utils/json-util.d.ts

@@ -0,0 +1,14 @@
+import _ from 'lodash';
+export declare type BasicJsonValue = boolean | number | string | null | undefined;
+export declare type JsonValue = BasicJsonValue | JsonArray | JsonMap;
+export interface JsonMap {
+    [key: string]: JsonValue | undefined;
+}
+export declare type JsonArray = JsonValue[];
+export declare class JsonBuilder {
+    readonly json: JsonMap;
+    constructor(json?: JsonMap);
+    add(key: string, value: JsonValue, serializeEmpty?: boolean): this;
+}
+export declare function recursiveDasherizeKeys(body: any): _.Dictionary<any>;
+export declare function dasherize(target: string): string;

package/dist/utils/json-util.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dasherize = exports.recursiveDasherizeKeys = exports.JsonBuilder = void 0;
+var lodash_1 = __importDefault(require("lodash"));
+var JsonBuilder = /** @class */ (function () {
+    function JsonBuilder(json) {
+        if (json === void 0) { json = {}; }
+        this.json = json;
+    }
+    JsonBuilder.prototype.add = function (key, value, serializeEmpty) {
+        if (serializeEmpty === void 0) { serializeEmpty = false; }
+        if ((lodash_1.default.isNil(value) || value === '') && !serializeEmpty) {
+            return this;
+        }
+        this.json[key] = value;
+        return this;
+    };
+    return JsonBuilder;
+}());
+exports.JsonBuilder = JsonBuilder;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function recursiveDasherizeKeys(body) {
+    var dasherized = lodash_1.default.mapKeys(body, function (_value, key) { return dasherize(key); });
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    dasherized = lodash_1.default.mapValues(dasherized, function (value) {
+        if (lodash_1.default.isPlainObject(value)) {
+            return recursiveDasherizeKeys(value);
+        }
+        return value;
+    });
+    return dasherized;
+}
+exports.recursiveDasherizeKeys = recursiveDasherizeKeys;
+function dasherize(target) {
+    // prettier-ignore
+    return target
+        .replace(/([A-Z])/g, function (_match, p1, _offset, _whole) { return "-".concat(p1.toLowerCase()); })
+        .replace(/\s/g, '-');
+}
+exports.dasherize = dasherize;

package/dist/utils/response-util.d.ts

@@ -0,0 +1 @@
+export default function extractResponseData(httpResponse: any): any;

package/dist/utils/response-util.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var lodash_1 = __importDefault(require("lodash"));
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function extractResponseData(httpResponse) {
+    if (lodash_1.default.has(httpResponse, 'data.data.items')) {
+        return lodash_1.default.get(httpResponse, 'data.data.items');
+    }
+    else if (lodash_1.default.has(httpResponse, 'data.data')) {
+        return lodash_1.default.get(httpResponse, 'data.data');
+    }
+    else {
+        return httpResponse;
+    }
+}
+exports.default = extractResponseData;
+// add login parser here
+// create unit tests for login parser, extractreponsedata