monarch-money-api 0.0.1

package/index2.js

@@ -0,0 +1,545 @@
+import fs from 'fs';
+import path from 'path';
+import fetch from 'node-fetch';
+import { GraphQLClient, gql } from 'graphql-request';
+import FormData from 'form-data';
+import readline from 'readline';
+import { promisify } from 'util';
+
+// Constants
+const AUTH_HEADER_KEY = "authorization";
+const CSRF_KEY = "csrftoken";
+const DEFAULT_RECORD_LIMIT = 100;
+const ERRORS_KEY = "error_code";
+const SESSION_DIR = ".mm";
+const SESSION_FILE = path.join(SESSION_DIR, "mm_session.json");
+
+// Helper function to create readline interface for interactive login
+const createInterface = () => readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+});
+
+// Monarch Money Endpoints
+const MonarchMoneyEndpoints = {
+    BASE_URL: "https://api.monarchmoney.com",
+
+    getLoginEndpoint() {
+        return `${this.BASE_URL}/auth/login/`;
+    },
+
+    getGraphQL() {
+        return `${this.BASE_URL}/graphql`;
+    },
+
+    getAccountBalanceHistoryUploadEndpoint() {
+        return `${this.BASE_URL}/account-balance-history/upload/`;
+    }
+};
+
+// Custom Exceptions
+class RequireMFAException extends Error {}
+class LoginFailedException extends Error {}
+class RequestFailedException extends Error {}
+
+// Session Management
+let headers = {
+    "Client-Platform": "web",
+};
+let token = null;
+let timeout = 10;
+let sessionFile = SESSION_FILE;
+
+const setToken = (newToken) => {
+    token = newToken;
+    headers["Authorization"] = `Token ${newToken}`;
+};
+
+const saveSession = (filename = sessionFile) => {
+    filename = path.resolve(filename);
+    const sessionData = { token };
+    fs.mkdirSync(path.dirname(filename), { recursive: true });
+    fs.writeFileSync(filename, JSON.stringify(sessionData));
+};
+
+const loadSession = (filename = sessionFile) => {
+    const data = JSON.parse(fs.readFileSync(filename, 'utf-8'));
+    setToken(data.token);
+};
+
+const deleteSession = (filename = sessionFile) => {
+    if (fs.existsSync(filename)) {
+        fs.unlinkSync(filename);
+    }
+};
+
+// GraphQL Client
+const getGraphQLClient = () => {
+    if (!headers["Authorization"]) {
+        throw new LoginFailedException("Make sure you call login() first or provide a session token!");
+    }
+    return new GraphQLClient(MonarchMoneyEndpoints.getGraphQL(), {
+        headers,
+        timeout: timeout * 1000,
+    });
+};
+
+// API Calls
+const gqlCall = async (operation, graphqlQuery, variables = {}) => {
+    const client = getGraphQLClient();
+    return await client.request(graphqlQuery, variables);
+};
+
+// User Interaction
+const interactiveLogin = async (useSavedSession = true, saveSessionFlag = true) => {
+    const rl = createInterface();
+    const email = await promisify(rl.question).bind(rl)("Email: ");
+    const passwd = await promisify(rl.question).bind(rl)("Password: ");
+    rl.close();
+
+    try {
+        await login(email, passwd, useSavedSession, saveSessionFlag);
+    } catch (error) {
+        if (error instanceof RequireMFAException) {
+            const rl = createInterface();
+            const twoFactorCode = await promisify(rl.question).bind(rl)("Two Factor Code: ");
+            rl.close();
+            await multiFactorAuthenticate(email, passwd, twoFactorCode);
+            if (saveSessionFlag) {
+                saveSession(sessionFile);
+            }
+        } else {
+            throw error;
+        }
+    }
+};
+
+const login = async (email = null, password = null, useSavedSession = true, saveSessionFlag = true, mfaSecretKey = null) => {
+    if (useSavedSession && fs.existsSync(sessionFile)) {
+        console.log(`Using saved session found at ${sessionFile}`);
+        loadSession(sessionFile);
+        return;
+    }
+
+    if (!email || !password) {
+        throw new LoginFailedException("Email and password are required to login when not using a saved session.");
+    }
+    await loginUser(email, password, mfaSecretKey);
+    if (saveSessionFlag) {
+        saveSession(sessionFile);
+    }
+};
+
+const loginUser = async (email, password, mfaSecretKey) => {
+    const data = new URLSearchParams({
+        password,
+        supports_mfa: true,
+        trusted_device: false,
+        username: email,
+    });
+
+    if (mfaSecretKey) {
+        data.append("totp", generateOtp(mfaSecretKey));
+    }
+
+    const response = await fetch(MonarchMoneyEndpoints.getLoginEndpoint(), {
+        method: 'POST',
+        headers,
+        body: data,
+    });
+
+    if (response.status === 403) {
+        throw new RequireMFAException("Multi-Factor Auth Required");
+    } else if (response.status !== 200) {
+        throw new LoginFailedException(`HTTP Code ${response.status}: ${response.statusText}`);
+    }
+
+    const json = await response.json();
+    setToken(json.token);
+};
+
+const multiFactorAuthenticate = async (email, password, code) => {
+    const data = new URLSearchParams({
+        password,
+        supports_mfa: true,
+        totp: code,
+        trusted_device: false,
+        username: email,
+    });
+
+    const response = await fetch(MonarchMoneyEndpoints.getLoginEndpoint(), {
+        method: 'POST',
+        headers,
+        body: data,
+    });
+
+    if (response.status !== 200) {
+        const json = await response.json();
+        const errorMessage = json[ERRORS_KEY] ? json[ERRORS_KEY] : "Unknown error";
+        throw new LoginFailedException(errorMessage);
+    }
+
+    const json = await response.json();
+    setToken(json.token);
+};
+
+// Sample API Method
+const getAccounts = async () => {
+    const query = gql`
+        query GetAccounts {
+            accounts {
+                ...AccountFields
+                __typename
+            }
+            householdPreferences {
+                id
+                accountGroupOrder
+                __typename
+            }
+        }
+        fragment AccountFields on Account {
+            id
+            displayName
+            syncDisabled
+            deactivatedAt
+            isHidden
+            isAsset
+            mask
+            createdAt
+            updatedAt
+            displayLastUpdatedAt
+            currentBalance
+            displayBalance
+            includeInNetWorth
+            hideFromList
+            hideTransactionsFromReports
+            includeBalanceInNetWorth
+            includeInGoalBalance
+            dataProvider
+            dataProviderAccountId
+            isManual
+            transactionsCount
+            holdingsCount
+            manualInvestmentsTrackingMethod
+            order
+            logoUrl
+            type {
+                name
+                display
+                __typename
+            }
+            subtype {
+                name
+                display
+                __typename
+            }
+            credential {
+                id
+                updateRequired
+                disconnectedFromDataProviderAt
+                dataProvider
+                institution {
+                    id
+                    plaidInstitutionId
+                    name
+                    status
+                    __typename
+                }
+                __typename
+            }
+            institution {
+                id
+                name
+                primaryColor
+                url
+                __typename
+            }
+            __typename
+        }
+    `;
+    return await gqlCall("GetAccounts", query);
+};
+
+// Additional functions translated here...
+export const getAccountTypeOptions = async () => {
+    const query = gql`
+        query GetAccountTypeOptions {
+            accountTypeOptions {
+                type {
+                    name
+                    display
+                    group
+                    possibleSubtypes {
+                        display
+                        name
+                        __typename
+                    }
+                    __typename
+                }
+                subtype {
+                    name
+                    display
+                    __typename
+                }
+                __typename
+            }
+        }
+    `;
+    return await gqlCall("GetAccountTypeOptions", query);
+};
+
+export const getRecentAccountBalances = async (startDate = null) => {
+    if (!startDate) {
+        startDate = new Date();
+        startDate.setDate(startDate.getDate() - 31);
+        startDate = startDate.toISOString().split('T')[0];
+    }
+
+    const query = gql`
+        query GetAccountRecentBalances($startDate: Date!) {
+            accounts {
+                id
+                recentBalances(startDate: $startDate)
+                __typename
+            }
+        }
+    `;
+    return await gqlCall("GetAccountRecentBalances", query, { startDate });
+};
+
+export const getAccountSnapshotsByType = async (startDate, timeframe) => {
+    if (!["year", "month"].includes(timeframe)) {
+        throw new Error(`Unknown timeframe "${timeframe}"`);
+    }
+
+    const query = gql`
+        query GetSnapshotsByAccountType($startDate: Date!, $timeframe: Timeframe!) {
+            snapshotsByAccountType(startDate: $startDate, timeframe: $timeframe) {
+                accountType
+                month
+                balance
+                __typename
+            }
+            accountTypes {
+                name
+                group
+                __typename
+            }
+        }
+    `;
+    return await gqlCall("GetSnapshotsByAccountType", query, { startDate, timeframe });
+};
+
+export const getAggregateSnapshots = async (startDate = null, endDate = null, accountType = null) => {
+    if (!startDate) {
+        startDate = new Date();
+        startDate.setFullYear(startDate.getFullYear() - 150);
+        startDate.setDate(1);
+        startDate = startDate.toISOString().split('T')[0];
+    }
+
+    const query = gql`
+        query GetAggregateSnapshots($filters: AggregateSnapshotFilters) {
+            aggregateSnapshots(filters: $filters) {
+                date
+                balance
+                __typename
+            }
+        }
+    `;
+
+    const variables = {
+        filters: {
+            startDate,
+            endDate,
+            accountType,
+        },
+    };
+
+    return await gqlCall("GetAggregateSnapshots", query, variables);
+};
+
+export const createManualAccount = async (accountType, accountSubType, isInNetWorth, accountName, accountBalance = 0) => {
+    const query = gql`
+        mutation Web_CreateManualAccount($input: CreateManualAccountMutationInput!) {
+            createManualAccount(input: $input) {
+                account {
+                    id
+                    __typename
+                }
+                errors {
+                    ...PayloadErrorFields
+                    __typename
+                }
+                __typename
+            }
+        }
+        fragment PayloadErrorFields on PayloadError {
+            fieldErrors {
+                field
+                messages
+                __typename
+            }
+            message
+            code
+            __typename
+        }
+    `;
+
+    const variables = {
+        input: {
+            type: accountType,
+            subtype: accountSubType,
+            includeInNetWorth: isInNetWorth,
+            name: accountName,
+            displayBalance: accountBalance,
+        },
+    };
+
+    return await gqlCall("Web_CreateManualAccount", query, variables);
+};
+
+export const updateAccount = async (accountId, accountName = null, accountBalance = null, accountType = null, accountSubType = null, includeInNetWorth = null, hideFromSummaryList = null, hideTransactionsFromReports = null) => {
+    const query = gql`
+        mutation Common_UpdateAccount($input: UpdateAccountMutationInput!) {
+            updateAccount(input: $input) {
+                account {
+                    ...AccountFields
+                    __typename
+                }
+                errors {
+                    ...PayloadErrorFields
+                    __typename
+                }
+                __typename
+            }
+        }
+        fragment AccountFields on Account {
+            id
+            displayName
+            syncDisabled
+            deactivatedAt
+            isHidden
+            isAsset
+            mask
+            createdAt
+            updatedAt
+            displayLastUpdatedAt
+            currentBalance
+            displayBalance
+            includeInNetWorth
+            hideFromList
+            hideTransactionsFromReports
+            includeBalanceInNetWorth
+            includeInGoalBalance
+            dataProvider
+            dataProviderAccountId
+            isManual
+            transactionsCount
+            holdingsCount
+            manualInvestmentsTrackingMethod
+            order
+            icon
+            logoUrl
+            deactivatedAt
+            type {
+                name
+                display
+                group
+                __typename
+            }
+            subtype {
+                name
+                display
+                __typename
+            }
+            credential {
+                id
+                updateRequired
+                disconnectedFromDataProviderAt
+                dataProvider
+                institution {
+                    id
+                    plaidInstitutionId
+                    name
+                    status
+                    __typename
+                }
+                __typename
+            }
+            institution {
+                id
+                name
+                primaryColor
+                url
+                __typename
+            }
+            __typename
+        }
+        fragment PayloadErrorFields on PayloadError {
+            fieldErrors {
+                field
+                messages
+                __typename
+            }
+            message
+            code
+            __typename
+        }
+    `;
+
+    const variables = {
+        input: {
+            id: accountId,
+            name: accountName,
+            type: accountType,
+            subtype: accountSubType,
+            includeInNetWorth,
+            hideFromList: hideFromSummaryList,
+            hideTransactionsFromReports,
+            displayBalance: accountBalance,
+        },
+    };
+
+    return await gqlCall("Common_UpdateAccount", query, variables);
+};
+
+export const deleteAccount = async (accountId) => {
+    const query = gql`
+        mutation Common_DeleteAccount($id: UUID!) {
+            deleteAccount(id: $id) {
+                deleted
+                errors {
+                    ...PayloadErrorFields
+                    __typename
+                }
+                __typename
+            }
+        }
+        fragment PayloadErrorFields on PayloadError {
+            fieldErrors {
+                field
+                messages
+                __typename
+            }
+            message
+            code
+            __typename
+        }
+    `;
+
+    const variables = { id: accountId };
+
+    return await gqlCall("Common_DeleteAccount", query, variables);
+};
+
+// Example of how you might use these functions
+(async () => {
+    try {
+        await interactiveLogin();
+        const accounts = await getAccounts();
+        console.log(accounts);
+    } catch (err) {
+        console.error(err);
+    }
+})();