otc-trading-desk 1.0.1-1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License Copyright (c) 2021
+
+Permission is hereby granted, free
+of charge, to any person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to the
+following conditions:
+
+The above copyright notice and this permission notice
+(including the next paragraph) shall be included in all copies or substantial
+portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO
+EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -0,0 +1,34 @@
+# otc-trading-desk
+
+CQL utility parserTrading desk react hooks
+
+## Features
+
+- ES6 syntax
+- React 16.8 hooks
+
+## Install
+
+```sh
+yarn add otc-trading-desk
+// or 
+npm i otc-trading-desk
+```
+
+### Requirements
+
+- Node.js `v12.x` or later
+- React 16.8
+
+
+### Usage
+
+```js
+import { convertToAST } from 'otc-trading-desk';
+
+const ast = convertToAST('Select * from table_name');
+
+ast.walk(node => {
+  // do your stuff.
+})
+```

package/hooks/index.js

@@ -0,0 +1,19 @@
+"use strict";
+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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+exports.__esModule = true;
+__exportStar(require("./useFetchOtcTradingDeskIndications"), exports);
+__exportStar(require("./useFetchOtcTradingDeskCustomerAccounts"), exports);
+__exportStar(require("./useOtcTradingDeskAccountsMap"), exports);

package/hooks/index.ts

@@ -0,0 +1,3 @@
+export * from "./useFetchOtcTradingDeskIndications";
+export * from "./useFetchOtcTradingDeskCustomerAccounts";
+export * from "./useOtcTradingDeskAccountsMap";

package/hooks/useFetchOtcTradingDeskCustomerAccounts.js

@@ -0,0 +1,117 @@
+"use strict";
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+exports.__esModule = true;
+exports.usePollOtcTradingDeskCustomerAccounts = exports.useClearOtcTradingDeskCustomerAccounts = exports.useRefreshOtcTradingDeskCustomerAccounts = exports.useFetchOtcTradingDeskCustomerAccounts = exports.getFetchOtcTradingDeskCustomerAccountsUrl = exports.validateOtcTradingDeskCustomerAccountsResult = exports.getOtcTradingDeskCustomerAccountsResultErrors = void 0;
+/* eslint-disable */
+// This file is copied from otc-trading-desk/hooks/useFetchOtcTradingDeskCustomerAccounts.ts
+// and modified to include an array of userIds encoded into the URL.
+// The reason for doing this is to reduce eng lift to removing MobX, and this is only done
+// because otc-trading-desk is a legacy app that hasn't been modified in years.
+// If otc-trading-desk is to be a first-class citizen in our repo down the line, this should
+// be refactored and we should fix the API layer to accept userIds without encoded [0] and [1] indexes.
+var React = require("react");
+var FetchProvider_1 = require("platform/contexts/network-primitives/FetchProvider/FetchProvider");
+var AuthTokenContext_1 = require("platform/contexts/environment/AuthTokenContext");
+var ApiOtcCustomerAccount_1 = require("platform/apiClient/generated/types/ApiOtcCustomerAccount");
+var getOtcTradingDeskCustomerAccountsResultErrors = function (values) {
+    if (!Array.isArray(values)) {
+        return [{ fieldName: '', error: 'Type mismatch: data should be an array' }];
+    }
+    return values.reduce(function (combinedErrors, value, index) {
+        var errors = (0, ApiOtcCustomerAccount_1.getApiOtcCustomerAccountErrors)(value);
+        if (errors.length) {
+            return __spreadArray(__spreadArray([], combinedErrors, true), [
+                {
+                    fieldName: "[".concat(index, "]"),
+                    errors: errors
+                },
+            ], false);
+        }
+        else {
+            return combinedErrors;
+        }
+    }, []);
+};
+exports.getOtcTradingDeskCustomerAccountsResultErrors = getOtcTradingDeskCustomerAccountsResultErrors;
+var validateOtcTradingDeskCustomerAccountsResult = function (value) {
+    var errors = (0, exports.getOtcTradingDeskCustomerAccountsResultErrors)(value);
+    if (errors.length) {
+        console.error("API Error: OtcTradingDeskCustomerAccountsResult data does not match contract.", errors);
+    }
+};
+exports.validateOtcTradingDeskCustomerAccountsResult = validateOtcTradingDeskCustomerAccountsResult;
+var getFetchOtcTradingDeskCustomerAccountsUrl = function (params) {
+    var searchParams = new URLSearchParams();
+    if (params.userIds !== null && params.userIds !== undefined) {
+        var val = params.userIds;
+        Array.isArray(val) &&
+            val.forEach(function (_, i) { return searchParams.append("user_ids[".concat(i, "]"), _); });
+    }
+    var url = "/otc-trading-desk/customers/accounts?".concat(searchParams);
+    return url;
+};
+exports.getFetchOtcTradingDeskCustomerAccountsUrl = getFetchOtcTradingDeskCustomerAccountsUrl;
+/**
+ * Fetch Gets an OTC customer's account balances
+ * @Url /otc-trading-desk/customers/accounts
+ * @Auth Required
+ */
+var useFetchOtcTradingDeskCustomerAccounts = function (params) {
+    var authId = (0, AuthTokenContext_1.useAuthTokens)().authId;
+    if (!authId) {
+        throw new Error('Attempted to fetch secure API endpoint without auth tokens.');
+    }
+    var url = (0, exports.getFetchOtcTradingDeskCustomerAccountsUrl)(params);
+    var data = (0, FetchProvider_1.useFetch)(url)[0];
+    if (process.env.NODE_ENV !== 'production') {
+        (0, exports.validateOtcTradingDeskCustomerAccountsResult)(data);
+    }
+    return data;
+};
+exports.useFetchOtcTradingDeskCustomerAccounts = useFetchOtcTradingDeskCustomerAccounts;
+/**
+ * Refresh Gets an OTC customer's account balances without throwing to suspense
+ * @Url /otc-trading-desk/customers/accounts
+ * @Auth Required
+ */
+var useRefreshOtcTradingDeskCustomerAccounts = function (params) {
+    var authId = (0, AuthTokenContext_1.useAuthTokens)().authId;
+    if (!authId) {
+        throw new Error('Attempted to fetch secure API endpoint without auth tokens.');
+    }
+    var url = (0, exports.getFetchOtcTradingDeskCustomerAccountsUrl)(params);
+    var fetchAndCacheItem = (0, FetchProvider_1.useFetchCacheDispatchers)().fetchAndCacheItem;
+    var refresh = React.useCallback(function () { return fetchAndCacheItem(url, true); }, [fetchAndCacheItem, url]);
+    return refresh;
+};
+exports.useRefreshOtcTradingDeskCustomerAccounts = useRefreshOtcTradingDeskCustomerAccounts;
+/**
+ * Remove Gets an OTC customer's account balances from cache without refetching. Subscribed components may refresh and throw to suspense.
+ * @Url /otc-trading-desk/customers/accounts
+ */
+var useClearOtcTradingDeskCustomerAccounts = function (params) {
+    var url = (0, exports.getFetchOtcTradingDeskCustomerAccountsUrl)(params);
+    var clearItem = (0, FetchProvider_1.useFetchCacheDispatchers)().clearItem;
+    var clear = React.useCallback(function () { return clearItem(url); }, [url, clearItem]);
+    return clear;
+};
+exports.useClearOtcTradingDeskCustomerAccounts = useClearOtcTradingDeskCustomerAccounts;
+/**
+ * Starts polling Gets an OTC customer's account balances
+ * @Url /otc-trading-desk/customers/accounts
+ * @maxAgeMs The maximum time since the resource was last fetched before it is refreshed.
+ */
+var usePollOtcTradingDeskCustomerAccounts = function (params, maxAgeMs) {
+    var url = (0, exports.getFetchOtcTradingDeskCustomerAccountsUrl)(params);
+    (0, FetchProvider_1.useFetchPolling)(url, maxAgeMs);
+};
+exports.usePollOtcTradingDeskCustomerAccounts = usePollOtcTradingDeskCustomerAccounts;
+exports["default"] = exports.useFetchOtcTradingDeskCustomerAccounts;

package/hooks/useFetchOtcTradingDeskCustomerAccounts.ts

@@ -0,0 +1,155 @@
+/* eslint-disable */
+// This file is copied from otc-trading-desk/hooks/useFetchOtcTradingDeskCustomerAccounts.ts
+// and modified to include an array of userIds encoded into the URL.
+// The reason for doing this is to reduce eng lift to removing MobX, and this is only done
+// because otc-trading-desk is a legacy app that hasn't been modified in years.
+// If otc-trading-desk is to be a first-class citizen in our repo down the line, this should
+// be refactored and we should fix the API layer to accept userIds without encoded [0] and [1] indexes.
+import * as React from 'react';
+import {
+    useFetch,
+    useFetchPolling,
+    useFetchCacheDispatchers,
+} from 'platform/contexts/network-primitives/FetchProvider/FetchProvider';
+import { useAuthTokens } from 'platform/contexts/environment/AuthTokenContext';
+import ApiOtcCustomerAccount, {
+    getApiOtcCustomerAccountErrors,
+} from 'platform/apiClient/generated/types/ApiOtcCustomerAccount';
+
+export type OtcTradingDeskCustomerAccountsArgs = {
+    /**
+     * Fetch customer account(s).
+     */
+    userIds?: string[];
+};
+
+export type OtcTradingDeskCustomerAccountsResult = ApiOtcCustomerAccount[];
+
+export const getOtcTradingDeskCustomerAccountsResultErrors = (
+    values: any
+): { fieldName: string; error: string }[] => {
+    if (!Array.isArray(values)) {
+        return [{ fieldName: '', error: 'Type mismatch: data should be an array' }];
+    }
+
+    return values.reduce((combinedErrors, value, index) => {
+        const errors = getApiOtcCustomerAccountErrors(value);
+        if (errors.length) {
+            return [
+                ...combinedErrors,
+                {
+                    fieldName: `[${index}]`,
+                    errors,
+                },
+            ];
+        } else {
+            return combinedErrors;
+        }
+    }, []);
+};
+
+export const validateOtcTradingDeskCustomerAccountsResult = (value: any) => {
+    const errors = getOtcTradingDeskCustomerAccountsResultErrors(value);
+    if (errors.length) {
+        console.error(
+            `API Error: OtcTradingDeskCustomerAccountsResult data does not match contract.`,
+            errors
+        );
+    }
+};
+
+export const getFetchOtcTradingDeskCustomerAccountsUrl = (
+    params: OtcTradingDeskCustomerAccountsArgs
+) => {
+    const searchParams = new URLSearchParams();
+    if (params.userIds !== null && params.userIds !== undefined) {
+        const val = params.userIds;
+        Array.isArray(val) &&
+            val.forEach((_, i) => searchParams.append(`user_ids[${i}]`, _));
+    }
+    const url = `/otc-trading-desk/customers/accounts?${searchParams}`;
+    return url;
+};
+
+/**
+ * Fetch Gets an OTC customer's account balances
+ * @Url /otc-trading-desk/customers/accounts
+ * @Auth Required
+ */
+export const useFetchOtcTradingDeskCustomerAccounts = (
+    params: OtcTradingDeskCustomerAccountsArgs
+) => {
+    const { authId } = useAuthTokens();
+    if (!authId) {
+        throw new Error(
+            'Attempted to fetch secure API endpoint without auth tokens.'
+        );
+    }
+
+    const url = getFetchOtcTradingDeskCustomerAccountsUrl(params);
+    const data = useFetch<OtcTradingDeskCustomerAccountsResult>(url)[0];
+
+    if (process.env.NODE_ENV !== 'production') {
+        validateOtcTradingDeskCustomerAccountsResult(data);
+    }
+
+    return data;
+};
+
+/**
+ * Refresh Gets an OTC customer's account balances without throwing to suspense
+ * @Url /otc-trading-desk/customers/accounts
+ * @Auth Required
+ */
+export const useRefreshOtcTradingDeskCustomerAccounts = (
+    params: OtcTradingDeskCustomerAccountsArgs
+) => {
+    const { authId } = useAuthTokens();
+    if (!authId) {
+        throw new Error(
+            'Attempted to fetch secure API endpoint without auth tokens.'
+        );
+    }
+
+    const url = getFetchOtcTradingDeskCustomerAccountsUrl(params);
+
+    const { fetchAndCacheItem } = useFetchCacheDispatchers();
+    const refresh = React.useCallback(
+        () => fetchAndCacheItem<OtcTradingDeskCustomerAccountsResult>(url, true),
+        [fetchAndCacheItem, url]
+    );
+
+    return refresh;
+};
+
+/**
+ * Remove Gets an OTC customer's account balances from cache without refetching. Subscribed components may refresh and throw to suspense.
+ * @Url /otc-trading-desk/customers/accounts
+ */
+export const useClearOtcTradingDeskCustomerAccounts = (
+    params: OtcTradingDeskCustomerAccountsArgs
+) => {
+    const url = getFetchOtcTradingDeskCustomerAccountsUrl(params);
+
+    const { clearItem } = useFetchCacheDispatchers();
+
+    const clear = React.useCallback(() => clearItem(url), [url, clearItem]);
+
+    return clear;
+};
+
+/**
+ * Starts polling Gets an OTC customer's account balances
+ * @Url /otc-trading-desk/customers/accounts
+ * @maxAgeMs The maximum time since the resource was last fetched before it is refreshed.
+ */
+export const usePollOtcTradingDeskCustomerAccounts = (
+    params: OtcTradingDeskCustomerAccountsArgs,
+    maxAgeMs: number
+) => {
+    const url = getFetchOtcTradingDeskCustomerAccountsUrl(params);
+
+    useFetchPolling(url, maxAgeMs);
+};
+
+export default useFetchOtcTradingDeskCustomerAccounts;

package/hooks/useFetchOtcTradingDeskIndications.js

@@ -0,0 +1,142 @@
+"use strict";
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+exports.__esModule = true;
+exports.usePollOtcTradingDeskIndications = exports.useClearOtcTradingDeskIndications = exports.useRefreshOtcTradingDeskIndications = exports.useFetchOtcTradingDeskIndications = exports.getFetchOtcTradingDeskIndicationsUrl = exports.validateOtcTradingDeskIndicationsResult = exports.getOtcTradingDeskIndicationsResultErrors = void 0;
+/* eslint-disable */
+// This file is copied from otc-trading-desk/hooks/useFetchOtcTradingDeskIndications.ts
+// and modified to include an array of statuses encoded into the URL.
+// The reason for doing this is to reduce eng lift to removing MobX, and this is only done
+// because otc-trading-desk is a legacy app that hasn't been modified in years.
+// If otc-trading-desk is to be a first-class citizen in our repo down the line, this should
+// be refactored and we should fix the API layer to accept statuses without encoded [0] and [1] indexes.
+var React = require("react");
+var FetchProvider_1 = require("platform/contexts/network-primitives/FetchProvider/FetchProvider");
+var AuthTokenContext_1 = require("platform/contexts/environment/AuthTokenContext");
+var ApiOtcIndication_1 = require("platform/apiClient/generated/types/ApiOtcIndication");
+var getOtcTradingDeskIndicationsResultErrors = function (values) {
+    if (!Array.isArray(values)) {
+        return [{ fieldName: '', error: 'Type mismatch: data should be an array' }];
+    }
+    return values.reduce(function (combinedErrors, value, index) {
+        var errors = (0, ApiOtcIndication_1.getApiOtcIndicationErrors)(value);
+        if (errors.length) {
+            return __spreadArray(__spreadArray([], combinedErrors, true), [
+                {
+                    fieldName: "[".concat(index, "]"),
+                    errors: errors
+                },
+            ], false);
+        }
+        else {
+            return combinedErrors;
+        }
+    }, []);
+};
+exports.getOtcTradingDeskIndicationsResultErrors = getOtcTradingDeskIndicationsResultErrors;
+var validateOtcTradingDeskIndicationsResult = function (value) {
+    var errors = (0, exports.getOtcTradingDeskIndicationsResultErrors)(value);
+    if (errors.length) {
+        console.error("API Error: OtcTradingDeskIndicationsResult data does not match contract.", errors);
+    }
+};
+exports.validateOtcTradingDeskIndicationsResult = validateOtcTradingDeskIndicationsResult;
+var getFetchOtcTradingDeskIndicationsUrl = function (params) {
+    var searchParams = new URLSearchParams();
+    if (params.userIds !== null && params.userIds !== undefined) {
+        var val = params.userIds;
+        Array.isArray(val) && val.forEach(function (_) { return searchParams.append('user_ids', _); });
+    }
+    if (params.profileIds !== null && params.profileIds !== undefined) {
+        var val = params.profileIds;
+        Array.isArray(val) && val.forEach(function (_) { return searchParams.append('profile_ids', _); });
+    }
+    if (params.searchSubstring !== null && params.searchSubstring !== undefined) {
+        var val = params.searchSubstring;
+        searchParams.append('search_substring', "".concat(val));
+    }
+    if (params.side !== null && params.side !== undefined) {
+        var val = params.side;
+        searchParams.append('side', "".concat(val));
+    }
+    if (params.limit !== null && params.limit !== undefined) {
+        var val = params.limit;
+        searchParams.append('limit', "".concat(val));
+    }
+    if (params.offset !== null && params.offset !== undefined) {
+        var val = params.offset;
+        searchParams.append('offset', "".concat(val));
+    }
+    if (params.statuses !== null && params.statuses !== undefined) {
+        var val = params.statuses;
+        // NOTE: IF CODEGEN NEEDS TO BE UPDATED - this line is the only difference from otc-trading-desk/hooks/useFetchOtcTradingDeskIndications.ts.
+        Array.isArray(val) &&
+            val.forEach(function (_, i) { return searchParams.append("statuses[".concat(i, "]"), _); });
+    }
+    var url = "/otc-trading-desk/indications?".concat(searchParams);
+    return url;
+};
+exports.getFetchOtcTradingDeskIndicationsUrl = getFetchOtcTradingDeskIndicationsUrl;
+/**
+ * Fetch Gets all OTC trading desk orders
+ * @Url /otc-trading-desk/indications
+ * @Auth Required
+ */
+var useFetchOtcTradingDeskIndications = function (params) {
+    var authId = (0, AuthTokenContext_1.useAuthTokens)().authId;
+    if (!authId) {
+        throw new Error('Attempted to fetch secure API endpoint without auth tokens.');
+    }
+    var url = (0, exports.getFetchOtcTradingDeskIndicationsUrl)(params);
+    var data = (0, FetchProvider_1.useFetch)(url)[0];
+    if (process.env.NODE_ENV !== 'production') {
+        (0, exports.validateOtcTradingDeskIndicationsResult)(data);
+    }
+    return data;
+};
+exports.useFetchOtcTradingDeskIndications = useFetchOtcTradingDeskIndications;
+/**
+ * Refresh Gets all OTC trading desk orders without throwing to suspense
+ * @Url /otc-trading-desk/indications
+ * @Auth Required
+ */
+var useRefreshOtcTradingDeskIndications = function (params) {
+    var authId = (0, AuthTokenContext_1.useAuthTokens)().authId;
+    if (!authId) {
+        throw new Error('Attempted to fetch secure API endpoint without auth tokens.');
+    }
+    var url = (0, exports.getFetchOtcTradingDeskIndicationsUrl)(params);
+    var fetchAndCacheItem = (0, FetchProvider_1.useFetchCacheDispatchers)().fetchAndCacheItem;
+    var refresh = React.useCallback(function () { return fetchAndCacheItem(url, true); }, [fetchAndCacheItem, url]);
+    return refresh;
+};
+exports.useRefreshOtcTradingDeskIndications = useRefreshOtcTradingDeskIndications;
+/**
+ * Remove Gets all OTC trading desk orders from cache without refetching. Subscribed components may refresh and throw to suspense.
+ * @Url /otc-trading-desk/indications
+ */
+var useClearOtcTradingDeskIndications = function (params) {
+    var url = (0, exports.getFetchOtcTradingDeskIndicationsUrl)(params);
+    var clearItem = (0, FetchProvider_1.useFetchCacheDispatchers)().clearItem;
+    var clear = React.useCallback(function () { return clearItem(url); }, [url, clearItem]);
+    return clear;
+};
+exports.useClearOtcTradingDeskIndications = useClearOtcTradingDeskIndications;
+/**
+ * Starts polling Gets all OTC trading desk orders
+ * @Url /otc-trading-desk/indications
+ * @maxAgeMs The maximum time since the resource was last fetched before it is refreshed.
+ */
+var usePollOtcTradingDeskIndications = function (params, maxAgeMs) {
+    var url = (0, exports.getFetchOtcTradingDeskIndicationsUrl)(params);
+    (0, FetchProvider_1.useFetchPolling)(url, maxAgeMs);
+};
+exports.usePollOtcTradingDeskIndications = usePollOtcTradingDeskIndications;
+exports["default"] = exports.useFetchOtcTradingDeskIndications;

package/hooks/useFetchOtcTradingDeskIndications.ts

@@ -0,0 +1,216 @@
+/* eslint-disable */
+// This file is copied from otc-trading-desk/hooks/useFetchOtcTradingDeskIndications.ts
+// and modified to include an array of statuses encoded into the URL.
+// The reason for doing this is to reduce eng lift to removing MobX, and this is only done
+// because otc-trading-desk is a legacy app that hasn't been modified in years.
+// If otc-trading-desk is to be a first-class citizen in our repo down the line, this should
+// be refactored and we should fix the API layer to accept statuses without encoded [0] and [1] indexes.
+import * as React from 'react';
+import {
+    useFetch,
+    useFetchPolling,
+    useFetchCacheDispatchers,
+} from 'platform/contexts/network-primitives/FetchProvider/FetchProvider';
+import { useAuthTokens } from 'platform/contexts/environment/AuthTokenContext';
+import ApiOtcIndication, {
+    getApiOtcIndicationErrors,
+} from 'platform/apiClient/generated/types/ApiOtcIndication';
+
+export type OtcTradingDeskIndicationsArgs = {
+    /**
+     * No description provided
+     */
+    userIds?: string[];
+
+    /**
+     * No description provided
+     */
+    profileIds?: string[];
+
+    /**
+     * No description provided
+     */
+    searchSubstring?: string;
+
+    /**
+     * No description provided
+     */
+    side?: 'buy' | 'sell';
+
+    /**
+     * No description provided
+     */
+    limit?: number;
+
+    /**
+     * No description provided
+     */
+    offset?: number;
+
+    /**
+     * No description provided
+     */
+    statuses?: ('received' | 'progress' | 'canceled' | 'done' | 'expired')[];
+};
+
+export type OtcTradingDeskIndicationsResult = ApiOtcIndication[];
+
+export const getOtcTradingDeskIndicationsResultErrors = (
+    values: any
+): { fieldName: string; error: string }[] => {
+    if (!Array.isArray(values)) {
+        return [{ fieldName: '', error: 'Type mismatch: data should be an array' }];
+    }
+
+    return values.reduce((combinedErrors, value, index) => {
+        const errors = getApiOtcIndicationErrors(value);
+        if (errors.length) {
+            return [
+                ...combinedErrors,
+                {
+                    fieldName: `[${index}]`,
+                    errors,
+                },
+            ];
+        } else {
+            return combinedErrors;
+        }
+    }, []);
+};
+
+export const validateOtcTradingDeskIndicationsResult = (value: any) => {
+    const errors = getOtcTradingDeskIndicationsResultErrors(value);
+    if (errors.length) {
+        console.error(
+            `API Error: OtcTradingDeskIndicationsResult data does not match contract.`,
+            errors
+        );
+    }
+};
+
+export const getFetchOtcTradingDeskIndicationsUrl = (
+    params: OtcTradingDeskIndicationsArgs
+) => {
+    const searchParams = new URLSearchParams();
+    if (params.userIds !== null && params.userIds !== undefined) {
+        const val = params.userIds;
+        Array.isArray(val) && val.forEach(_ => searchParams.append('user_ids', _));
+    }
+
+    if (params.profileIds !== null && params.profileIds !== undefined) {
+        const val = params.profileIds;
+        Array.isArray(val) && val.forEach(_ => searchParams.append('profile_ids', _));
+    }
+
+    if (params.searchSubstring !== null && params.searchSubstring !== undefined) {
+        const val = params.searchSubstring;
+        searchParams.append('search_substring', `${val}`);
+    }
+
+    if (params.side !== null && params.side !== undefined) {
+        const val = params.side;
+        searchParams.append('side', `${val}`);
+    }
+
+    if (params.limit !== null && params.limit !== undefined) {
+        const val = params.limit;
+        searchParams.append('limit', `${val}`);
+    }
+
+    if (params.offset !== null && params.offset !== undefined) {
+        const val = params.offset;
+        searchParams.append('offset', `${val}`);
+    }
+
+    if (params.statuses !== null && params.statuses !== undefined) {
+        const val = params.statuses;
+        // NOTE: IF CODEGEN NEEDS TO BE UPDATED - this line is the only difference from otc-trading-desk/hooks/useFetchOtcTradingDeskIndications.ts.
+        Array.isArray(val) &&
+            val.forEach((_, i) => searchParams.append(`statuses[${i}]`, _));
+    }
+    const url = `/otc-trading-desk/indications?${searchParams}`;
+    return url;
+};
+
+/**
+ * Fetch Gets all OTC trading desk orders
+ * @Url /otc-trading-desk/indications
+ * @Auth Required
+ */
+export const useFetchOtcTradingDeskIndications = (
+    params: OtcTradingDeskIndicationsArgs
+) => {
+    const { authId } = useAuthTokens();
+    if (!authId) {
+        throw new Error(
+            'Attempted to fetch secure API endpoint without auth tokens.'
+        );
+    }
+
+    const url = getFetchOtcTradingDeskIndicationsUrl(params);
+    const data = useFetch<OtcTradingDeskIndicationsResult>(url)[0];
+
+    if (process.env.NODE_ENV !== 'production') {
+        validateOtcTradingDeskIndicationsResult(data);
+    }
+
+    return data;
+};
+
+/**
+ * Refresh Gets all OTC trading desk orders without throwing to suspense
+ * @Url /otc-trading-desk/indications
+ * @Auth Required
+ */
+export const useRefreshOtcTradingDeskIndications = (
+    params: OtcTradingDeskIndicationsArgs
+) => {
+    const { authId } = useAuthTokens();
+    if (!authId) {
+        throw new Error(
+            'Attempted to fetch secure API endpoint without auth tokens.'
+        );
+    }
+
+    const url = getFetchOtcTradingDeskIndicationsUrl(params);
+
+    const { fetchAndCacheItem } = useFetchCacheDispatchers();
+    const refresh = React.useCallback(
+        () => fetchAndCacheItem<OtcTradingDeskIndicationsResult>(url, true),
+        [fetchAndCacheItem, url]
+    );
+
+    return refresh;
+};
+
+/**
+ * Remove Gets all OTC trading desk orders from cache without refetching. Subscribed components may refresh and throw to suspense.
+ * @Url /otc-trading-desk/indications
+ */
+export const useClearOtcTradingDeskIndications = (
+    params: OtcTradingDeskIndicationsArgs
+) => {
+    const url = getFetchOtcTradingDeskIndicationsUrl(params);
+
+    const { clearItem } = useFetchCacheDispatchers();
+
+    const clear = React.useCallback(() => clearItem(url), [url, clearItem]);
+
+    return clear;
+};
+
+/**
+ * Starts polling Gets all OTC trading desk orders
+ * @Url /otc-trading-desk/indications
+ * @maxAgeMs The maximum time since the resource was last fetched before it is refreshed.
+ */
+export const usePollOtcTradingDeskIndications = (
+    params: OtcTradingDeskIndicationsArgs,
+    maxAgeMs: number
+) => {
+    const url = getFetchOtcTradingDeskIndicationsUrl(params);
+
+    useFetchPolling(url, maxAgeMs);
+};
+
+export default useFetchOtcTradingDeskIndications;

package/hooks/useOtcTradingDeskAccountsMap.js

@@ -0,0 +1,75 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+exports.__esModule = true;
+exports.useRefreshOtcTradingDeskAccountsMap = exports.useOtcTradingDeskAccountsMap = void 0;
+var react_1 = require("react");
+var withError_1 = require("platform/hooks/core/withError");
+var useFetchOtcTradingDeskCustomerAccounts_1 = require("otc-trading-desk/hooks/useFetchOtcTradingDeskCustomerAccounts");
+var accountsMap = {};
+var addToAccountsMap = function (accounts) {
+    var newAccountsMap = {};
+    accounts.forEach(function (account) {
+        if (newAccountsMap[account.userId]) {
+            newAccountsMap[account.userId] = __spreadArray(__spreadArray([], newAccountsMap[account.userId], true), [
+                account,
+            ], false);
+        }
+        else {
+            newAccountsMap[account.userId] = [account];
+        }
+    });
+    var updatedMap = __assign(__assign({}, accountsMap), newAccountsMap);
+    accountsMap = updatedMap;
+    return updatedMap;
+};
+var useOtcTradingDeskAccountsMap = function (userIds, isTradingDesk) {
+    var userIdsWithFallback = userIds && userIds.length ? userIds : [''];
+    var newAccounts = null;
+    if (isTradingDesk) {
+        newAccounts = (0, withError_1["default"])(function () {
+            // eslint-disable-next-line react-hooks/rules-of-hooks
+            return (0, useFetchOtcTradingDeskCustomerAccounts_1.useFetchOtcTradingDeskCustomerAccounts)({ userIds: userIdsWithFallback });
+        })[0];
+    }
+    return (0, react_1.useMemo)(function () {
+        if (!newAccounts)
+            return {};
+        var updatedMap = addToAccountsMap(newAccounts);
+        return updatedMap;
+    }, [newAccounts]);
+};
+exports.useOtcTradingDeskAccountsMap = useOtcTradingDeskAccountsMap;
+var useRefreshOtcTradingDeskAccountsMap = function (userIds) {
+    var refreshAccounts = (0, useFetchOtcTradingDeskCustomerAccounts_1.useRefreshOtcTradingDeskCustomerAccounts)({ userIds: userIds });
+    return function () {
+        if (!userIds || !userIds.length)
+            return Promise.resolve({});
+        return refreshAccounts().then(function (response) {
+            if (!(response instanceof Error)) {
+                var updatedMap = addToAccountsMap(response.body);
+                return updatedMap;
+            }
+            return {};
+        });
+    };
+};
+exports.useRefreshOtcTradingDeskAccountsMap = useRefreshOtcTradingDeskAccountsMap;

package/hooks/useOtcTradingDeskAccountsMap.ts

@@ -0,0 +1,62 @@
+import { useMemo } from 'react';
+import withError from 'platform/hooks/core/withError';
+import ApiOtcCustomerAccount from 'platform/apiClient/generated/types/ApiOtcCustomerAccount';
+import {
+    useFetchOtcTradingDeskCustomerAccounts,
+    useRefreshOtcTradingDeskCustomerAccounts,
+} from 'otc-trading-desk/hooks/useFetchOtcTradingDeskCustomerAccounts';
+
+let accountsMap: Record<string, readonly ApiOtcCustomerAccount[]> = {};
+
+const addToAccountsMap = (accounts: readonly ApiOtcCustomerAccount[]) => {
+    const newAccountsMap: Record<string, readonly ApiOtcCustomerAccount[]> = {};
+    accounts.forEach(account => {
+        if (newAccountsMap[account.userId]) {
+            newAccountsMap[account.userId] = [
+                ...newAccountsMap[account.userId],
+                account,
+            ];
+        } else {
+            newAccountsMap[account.userId] = [account];
+        }
+    });
+    const updatedMap = { ...accountsMap, ...newAccountsMap };
+    accountsMap = updatedMap;
+    return updatedMap;
+};
+
+export const useOtcTradingDeskAccountsMap = (
+    userIds: string[],
+    isTradingDesk: boolean
+) => {
+    const userIdsWithFallback = userIds && userIds.length ? userIds : [''];
+    let newAccounts: readonly ApiOtcCustomerAccount[] | null = null;
+    if (isTradingDesk) {
+        [newAccounts] = withError(() =>
+            // eslint-disable-next-line react-hooks/rules-of-hooks
+            useFetchOtcTradingDeskCustomerAccounts({ userIds: userIdsWithFallback })
+        );
+    }
+    return useMemo(() => {
+        if (!newAccounts) return {};
+        const updatedMap = addToAccountsMap(newAccounts);
+        return updatedMap;
+    }, [newAccounts]);
+};
+
+export const useRefreshOtcTradingDeskAccountsMap = (userIds: string[]) => {
+    const refreshAccounts = useRefreshOtcTradingDeskCustomerAccounts({ userIds });
+    return () => {
+        if (!userIds || !userIds.length)
+            return Promise.resolve(
+                {} as Record<string, readonly ApiOtcCustomerAccount[]>
+            );
+        return refreshAccounts().then(response => {
+            if (!(response instanceof Error)) {
+                const updatedMap = addToAccountsMap(response.body);
+                return updatedMap;
+            }
+            return {};
+        });
+    };
+};

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "otc-trading-desk",
+  "version": "1.0.1-1",
+  "private": false,
+  "description": "Trading desk react hooks",
+  "license": "MIT",
+  "author": "hcnbs",
+  "repository": "https://www.github.com/hcnbs/otc-trading-desk",
+  "main": "dist/hooks/index.js",
+  "scripts": {
+    "build": "tsc",
+    "test": "jest"
+  },
+  "dependencies": {
+    "react": "^16.8.6"
+  },
+  "devDependencies": {
+    "jest": "28.1.3",
+    "typescript": "^4.7.2"
+  },
+  "keywords": ["react hooks", "trading desk"],
+  "publishConfig": {
+    "access": "public"
+  }
+}