@gooin/garmin-connect 1.4.4

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Oskar Bernberg
+
+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 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,236 @@
+
+
+# garmin-connect  
+A powerful JavaScript library for connecting to Garmin Connect for sending and receiving health and workout data. It comes with some predefined methods to get and set different kinds of data for your Garmin account, but also have the possibility to make [custom requests](#custom-requests) `GET`, `POST` and `PUT` are currently supported. This makes it easy to implement whatever may be missing to suite your needs.
+
+## Prerequisites
+This library will require you to add a configuration file to your project root called `garmin.config.json` containing your username and password for the Garmin Connect service.
+```json
+{
+	"username": "my.email@example.com",
+	"password": "MySecretPassword" 
+}
+```
+## How to install
+```shell
+$ npm install garmin-connect
+```
+## How to use
+```js
+const { GarminConnect } = require('garmin-connect');
+// Create a new Garmin Connect Client
+const GCClient = new GarminConnect();
+// Uses credentials from garmin.config.json or uses supplied params
+await GCClient.login('my.email@example.com', 'MySecretPassword');
+const userInfo = await GCClient.getUserInfo();
+```
+Now you can check `userInfo.emailAddress` to verify that your login was successful.
+
+## Reusing your session
+This is an experimental feature and might not yet provide full stability.
+
+After a successful login the ```sessionJson``` getter and setter can be used to export and restore your session.
+```js
+// Exporting the session
+const session = GCClient.sessionJson;
+
+// Use this instead of GCClient.login() to restore the session
+// This will throw an error if the stored session cannot be reused
+GCClient.restore(session);
+```
+The exported session should be serializable and can be stored as a JSON string.
+
+A stored session can only be reused once and will need to be stored after each request. This can be done by attaching some storage to the ```sessionChange``` event.
+```js
+GCClient.onSessionChange(session => {
+    /*
+        Your choice of storage here
+        node-persist will probably work in most cases 
+     */
+});
+```
+
+### Login fallback
+To make sure to use a stored session if possible, but fallback to regular login, one can use the ```restoreOrLogin``` method.
+The arguments ```username``` and ```password``` are both optional and the regular ```.login()``` will be 
+called if session restore fails.
+```js
+await GCClient.restoreOrLogin(session, username, password);
+```
+
+## Events
+
+* ```sessionChange``` will trigger on a change in the current ```sessionJson```
+
+To attach a listener to an event, use the ```.on()``` method.
+```js
+GCClient.on('sessionChange', session => console.log(session));
+```
+There's currently no way of removing listeners.
+
+## Reading data
+### User info
+Receive basic user information
+```js
+GCClient.getUserInfo();
+```
+### Social Profile
+Receive social user information
+```js
+GCClient.getSocialProfile();
+```
+### Social Connections
+Get a list of all social connections
+```js
+GCClient.getSocialConnections();
+```
+### Device info
+Get a list of all registered devices including model numbers and firmware versions.
+```js
+GCClient.getDeviceInfo();
+```
+### Activities
+To get a list of recent activities, use the `getActivities` method. This function takes two arguments, *start* and *limit*, which is used for pagination. Both are optional and will default to whatever Garmin Connect is using. To be sure to get all activities, use this correctly.
+```js
+// Get a list of default length with most recent activities
+GCClient.getActivities();
+// Get activities 10 through 15. (start 10, limit 5)
+GCClient.getActivities(10, 5);
+```
+### Activity details
+Use the activityId to get details about that specific activity.
+```js
+const activities = await GCClient.getActivities(0, 1);
+const id = activities[0].activityId;
+// Use the id as a parameter 
+GCClient.getActivity({ activityId: id });
+// Or the whole activity response
+GCClient.getActivity(activities[0]);
+```
+### Activities
+To get a list of activities in your news feed, use the `getNewsFeed` method. This function takes two arguments, *start* and *limit*, which is used for pagination. Both are optional and will default to whatever Garmin Connect is using. To be sure to get all activities, use this correctly.
+```js
+// Get the news feed with a default length with most recent activities
+GCClient.getNewsFeed();
+// Get activities in feed, 10 through 15. (start 10, limit 5)
+GCClient.getNewsFeed(10, 5);
+```
+### Download original activity data
+Use the activityId to download the original activity data. Usually this is supplied as a .zip file.
+```js
+const [activity] = await GCClient.getActivities(0, 1);
+// Directory path is optional and defaults to the current working directory.
+// Downloads filename will be supplied by Garmin.
+GCClient.downloadOriginalActivityData(activity, './some/path/that/exists');
+```
+### Upload activity file
+Uploads an activity file as a new Activity. The file can be a `gpx`, `tcx`, or `fit` file. If the activity already exists, the result will have a status code of 409.
+Upload fixed in 1.4.4, Garmin changed the upload api, the response `detailedImportResult` doesn't contain the new activityId.
+```js
+
+const upload = await GCClient.uploadActivity('./some/path/to/file.fit');
+// not working
+const activityId = upload.detailedImportResult.successes[0].internalId;
+
+const uploadId = upload.detailedImportResult.uploadId;
+```
+### Step count
+Get timestamp and number of steps taken for a specific date.
+```js
+// This will default to today if no date is supplied
+const steps = await GCClient.getSteps(new Date('2020-03-24'));
+```
+### Heart rate
+Get heart rate for a specific date.
+```js
+// This will default to today if no date is supplied
+const heartRate = await GCClient.getHeartRate(new Date('2020-03-24'));
+```
+### Sleep summary
+Get the summary of how well you've slept for a specific date.
+```js
+// This will default to today if no date is supplied
+const sleep = await GCClient.getSleep(new Date('2020-03-24'));
+```
+### Detailed sleep data
+Get the details of your sleep for a specific date.
+```js
+// This will default to today if no date is supplied
+const detailedSleep = await GCClient.getSleepData(new Date('2020-03-24'));
+```
+## Modifying data
+### Update activity
+```js
+const activities = await GCClient.getActivities(0, 1);
+const activity = activities[0];
+activity['activityName'] = 'The Updated Name';
+await GCClient.updateActivity(activity);
+```
+### Delete an activity
+Deletes an activty.
+```js
+const activities = await GCClient.getActivities(0, 1);
+const activity = activities[0];
+await GCClient.deleteActivity(activity);
+```
+### Add weight
+To add a new weight measurement, use `setBodyWeight`. Here you specify your weight in *kg*.
+```js
+GCClient.setBodyWeight(81.4);
+```
+Will set your current weight to 81.4kg. The unit used might be tied to your preferred weight settings.
+### Add workout
+To add a custom workout, use the `addWorkout` or more specifically `addRunningWorkout`.
+```js
+GCClient.addRunningWorkout('My 5k run', 5000, 'Some description');
+```
+Will add a running workout of 5km called 'My 5k run' and return a JSON object representing the saved workout.
+### Schedule workout
+To add a workout to your calendar, first find your workout and then add it to a specific date.
+```js
+const workouts = await GCClient.getWorkouts();
+const id = workouts[0].workoutId;
+GCClient.scheduleWorkout({ workoutId: id }, new Date('2020-03-24'));
+```
+This will add the workout to a specific date in your calendar and make it show up automatically if you're using any of the Garmin watches.
+### Delete workout
+Deleting a workout is very similar to [scheduling](#schedule-workout) one.
+```js
+const workouts = await GCClient.getWorkouts();
+const id = workouts[0].workoutId;
+GCClient.deleteWorkout({ workoutId: id });
+```
+
+## Custom requests
+This library will handle custom requests to your active Garmin Connect session. There are a lot of different url's that is used, which means that this library probably wont cover them all. By using the network analyze tool you can find url's that are used by Garmin Connect to fetch data.
+
+Let's assume I found a `GET` requests to the following url:
+```
+https://connect.garmin.com/modern/proxy/wellness-service/wellness/dailyHeartRate/22f5f84c-de9d-4ad6-97f2-201097b3b983?date=2020-03-24
+```
+The request can be sent using `GCClient` by running
+```js
+// You can get your displayName by using the getUserInfo method;
+const displayName = '22f5f84c-de9d-4ad6-97f2-201097b3b983';
+const url = 'https://connect.garmin.com/modern/proxy/wellness-service/wellness/dailyHeartRate/';
+const dateString = '2020-03-24';
+GCClient.get(url + displayName, { date: dateString });
+```
+and will net you the same result as using the provided way
+```js
+GCClient.getHeartRate();
+```
+Notice how the client will keep track of the url's, your user information as well as keeping the session alive.
+## Limitations
+For now, this library only supports the following:
+* Get user info
+* Get social user info
+* Get heart rate
+* Set body weight
+* Get list of workouts
+* Add new workouts
+* Add workouts to you calendar
+* Remove previously added workouts
+* Get list of activities
+* Get details about one specific activity
+* Get the step count

package/dist/common/CFClient.js

@@ -0,0 +1,140 @@
+const cloudscraper = require('cloudscraper');
+const qs = require('qs');
+const request = require('request');
+const fs = require('fs');
+const path = require('path');
+
+const asJson = (body) => {
+    try {
+        const jsonBody = JSON.parse(body);
+        return jsonBody;
+    } catch (e) {
+        // Do nothing
+    }
+    return body;
+};
+
+class CFClient {
+    constructor(headers) {
+        this.cloudscraper = cloudscraper;
+        this.queryString = qs;
+        this.cookies = request.jar();
+        this.headers = headers || {};
+    }
+
+    serializeCookies() {
+        // eslint-disable-next-line no-underscore-dangle
+        return this.cookies._jar.serializeSync();
+    }
+
+    importCookies(cookies) {
+        // eslint-disable-next-line no-underscore-dangle
+        const deserialized = this.cookies._jar.constructor.deserializeSync(cookies);
+        this.cookies = request.jar();
+        // eslint-disable-next-line no-underscore-dangle
+        this.cookies._jar = deserialized;
+    }
+
+    async scraper(options) {
+        return new Promise((resolve) => {
+            this.cloudscraper(
+                options,
+                (err, res) => {
+                    resolve(res);
+                },
+            );
+        });
+    }
+
+    /**
+     * @param {string} downloadDir
+     * @param {string} url
+     * @param {*} data
+     */
+    async downloadBlob(downloadDir = '', url, data) {
+        const queryData = this.queryString.stringify(data);
+        const queryDataString = queryData ? `?${queryData}` : '';
+        const options = {
+            method: 'GET',
+            jar: this.cookies,
+            uri: `${url}${queryDataString}`,
+            headers: this.headers,
+            encoding: 0,
+        };
+        return new Promise((resolve) => {
+            this.cloudscraper(
+                options,
+                async (err, response, body) => {
+                    const { headers } = response || {};
+                    const { 'content-disposition': contentDisposition } = headers || {};
+                    const downloadDirNormalized = path.normalize(downloadDir);
+                    if (contentDisposition) {
+                        const defaultName = `garmin_connect_download_${Date.now()}`;
+                        const [, fileName = defaultName] = contentDisposition.match(/filename="?([^"]+)"?/);
+                        const filePath = path.resolve(downloadDirNormalized, fileName);
+                        fs.writeFileSync(filePath, body);
+                        resolve(filePath);
+                    }
+                },
+            );
+        });
+    }
+
+    async get(url, data) {
+        const queryData = this.queryString.stringify(data);
+        const queryDataString = queryData ? `?${queryData}` : '';
+        const options = {
+            method: 'GET',
+            jar: this.cookies,
+            uri: `${url}${queryDataString}`,
+            headers: this.headers,
+        };
+        const { body } = await this.scraper(options);
+        return asJson(body);
+    }
+
+    async post(url, data) {
+        const options = {
+            method: 'POST',
+            uri: url,
+            jar: this.cookies,
+            formData: data,
+            headers: this.headers,
+        };
+        const { body } = await this.scraper(options);
+        return asJson(body);
+    }
+
+    async postJson(url, data, params, headers) {
+        const options = {
+            method: 'POST',
+            uri: url,
+            jar: this.cookies,
+            json: data,
+            headers: {
+                ...this.headers,
+                ...headers,
+                'Content-Type': 'application/json',
+            },
+        };
+        const { body } = await this.scraper(options);
+        return asJson(body);
+    }
+
+    async putJson(url, data) {
+        const options = {
+            method: 'PUT',
+            uri: url,
+            jar: this.cookies,
+            json: data,
+            headers: {
+                ...this.headers,
+                'Content-Type': 'application/json',
+            },
+        };
+        const { body } = await this.scraper(options);
+        return asJson(body);
+    }
+}
+
+module.exports = CFClient;

package/dist/common/Client.js

@@ -0,0 +1,189 @@
+const axios = require('axios');
+const qs = require('qs');
+const fs = require('fs');
+const stream = require('stream');
+const util = require('util');
+const path = require('path');
+
+const pipeline = util.promisify(stream.pipeline);
+
+class Client {
+    constructor(headers) {
+        this.axios = axios;
+        this.queryString = qs;
+        this.fs = fs;
+        this.headers = headers || {};
+        this.cookies = {};
+    }
+
+    setCookie(name, value) {
+        this.cookies[name] = value;
+        this.headers.Cookie = this.getCookieString();
+    }
+
+    parseCookies(response) {
+        const setCookies = response && response.headers && response.headers['set-cookie'];
+        if (setCookies) {
+            setCookies.forEach((c) => {
+                const [cookieValue] = c.split(';');
+                const [name, value] = cookieValue.split('=');
+                this.setCookie(name, value);
+            });
+        }
+        return response;
+    }
+
+    getCookie(name) {
+        return this.cookies[name];
+    }
+
+    getCookieString() {
+        return Object.entries(this.cookies).map((e) => `${e[0]}=${e[1]}`).join('; ');
+    }
+
+    post(url, data, params) {
+        return this.axios({
+            method: 'POST',
+            params,
+            url,
+            data: this.queryString.stringify(data),
+            headers: {
+                ...this.headers,
+                'Content-Type': 'application/x-www-form-urlencoded',
+            },
+            maxRedirects: 0,
+        })
+            .catch((r) => {
+                const { response } = r || {};
+                this.parseCookies(response);
+                if (response.status === 302 || response.status === 301) {
+                    if (response.headers && response.headers.location) {
+                        return this.post(response.headers.location, data, params);
+                    }
+                }
+                return r;
+            })
+            .then((r) => this.parseCookies(r))
+            .then((r) => r && r.data);
+    }
+
+    postJson(url, data, params, headers = {}) {
+        return this.axios({
+            method: 'POST',
+            params,
+            url,
+            data: JSON.stringify(data, null, 4),
+            headers: {
+                ...this.headers,
+                ...headers,
+                'Content-Type': 'application/json',
+            },
+        })
+            .then((r) => this.parseCookies(r))
+            .then((r) => r && r.data);
+    }
+
+    postBlob(url, formData, params, headers = {}) {
+        return this.axios({
+            method: 'POST',
+            params,
+            url,
+            data: formData,
+            headers: {
+                ...this.headers,
+                ...headers,
+                ...formData.getHeaders(),
+            },
+        })
+            .then((r) => this.parseCookies(r))
+            .then((r) => r && r.data);
+    }
+
+    putJson(url, data, params) {
+        return this.axios({
+            method: 'PUT',
+            params,
+            url,
+            data: JSON.stringify(data, null, 4),
+            headers: {
+                ...this.headers,
+                'Content-Type': 'application/json',
+            },
+        })
+            .then((r) => this.parseCookies(r))
+            .then((r) => r && r.data);
+    }
+
+    downloadBlob(downloadDir = '', url, data, params) {
+        const queryData = this.queryString.stringify(data);
+        const queryDataString = queryData ? `?${queryData}` : '';
+        return this.axios({
+            method: 'GET',
+            params,
+            responseType: 'stream',
+            url: `${url}${queryDataString}`,
+            headers: this.headers,
+            maxRedirects: 0,
+        })
+            .catch((r) => {
+                const { response } = r || {};
+                const { status, headers } = response || {};
+                const { location } = headers || {};
+                this.parseCookies(response);
+                if (status === 302 || status === 301) {
+                    if (headers && location) {
+                        return this.downloadBlob(location, data, params);
+                    }
+                }
+                return r;
+            })
+            .then((r) => this.parseCookies(r))
+            .then(async (r) => {
+                const { headers } = r || {};
+                const { 'content-disposition': contentDisposition } = headers || {};
+                const downloadDirNormalized = path.normalize(downloadDir);
+                if (contentDisposition) {
+                    const defaultName = `garmin_connect_download_${Date.now()}`;
+                    const [, fileName = defaultName] = contentDisposition.match(/filename="(.+)"/);
+                    const filePath = path.resolve(downloadDir, fileName);
+                    await pipeline(r.data, this.fs.createWriteStream(filePath));
+                    return filePath;
+                }
+                throw new Error(`Could not download file ${url} to ${downloadDirNormalized}`);
+            });
+    }
+
+    get(url, data, params) {
+        const queryData = this.queryString.stringify(data);
+        const queryDataString = queryData ? `?${queryData}` : '';
+        return this.axios({
+            method: 'GET',
+            params,
+            url: `${url}${queryDataString}`,
+            headers: this.headers,
+            maxRedirects: 0,
+        })
+            .catch((r) => {
+                const { response } = r || {};
+                const { status, headers } = response || {};
+                const { location } = headers || {};
+                this.parseCookies(response);
+                if (status === 302 || status === 301) {
+                    if (headers && location) {
+                        return this.get(location, data, params);
+                    }
+                }
+                return r;
+            })
+            .then((r) => this.parseCookies(r))
+            .then((r) => {
+                if (typeof r === 'string') {
+                    return r;
+                }
+                return r && r.data;
+            });
+    }
+}
+
+
+module.exports = Client;

package/dist/common/DateUtils.js

@@ -0,0 +1,10 @@
+const toDateString = (date) => {
+    const offset = date.getTimezoneOffset();
+    const offsetDate = new Date(date.getTime() - (offset * 60 * 1000));
+    const [dateString] = offsetDate.toISOString().split('T');
+    return dateString;
+};
+
+module.exports = {
+    toDateString,
+};

package/dist/garmin/GarminConnect.js

@@ -0,0 +1,438 @@
+const appRoot = require('app-root-path');
+const fs = require('fs');
+
+let config = {};
+try {
+    // eslint-disable-next-line
+    config = require(`${appRoot}/garmin.config.json`);
+} catch (e) {
+    // Do nothing
+}
+
+const CFClient = require('../common/CFClient');
+const { Running } = require('./workouts');
+const { toDateString } = require('../common/DateUtils');
+const urls = require('./Urls');
+
+const {
+    username: configUsername,
+    password: configPassword,
+} = config;
+
+const credentials = {
+    username: configUsername,
+    password: configPassword,
+    embed: 'false',
+};
+
+class GarminConnect {
+    constructor() {
+        const headers = {
+            origin: urls.GARMIN_SSO_ORIGIN,
+            nk: 'NT',
+        };
+        this.client = new CFClient(headers);
+        this.userHash = undefined;
+        this.listeners = {};
+        this.events = { sessionChange: 'sessionChange' };
+    }
+
+    get sessionJson() {
+        const cookies = this.client.serializeCookies();
+        return { cookies, userHash: this.userHash };
+    }
+
+    set sessionJson(json) {
+        const {
+            cookies,
+            userHash,
+        } = json || {};
+        if (cookies && userHash) {
+            this.userHash = userHash;
+            this.client.importCookies(cookies);
+        }
+    }
+
+    /**
+     * Add an event listener callback
+     * @param event
+     * @param callback
+     */
+    on(event, callback) {
+        if (event && callback && typeof event === 'string' && typeof callback === 'function') {
+            if (!this.listeners[event]) {
+                this.listeners[event] = [];
+            }
+            this.listeners[event].push(callback);
+        }
+    }
+
+    /**
+     * Method for triggering any event
+     * @param event
+     * @param data
+     */
+    triggerEvent(event, data) {
+        const callbacks = this.listeners[event] || [];
+        callbacks.forEach((cb) => cb(data));
+    }
+
+    /**
+     * Add a callback to the 'sessionChange' event
+     * @param callback
+     */
+    onSessionChange(callback) {
+        this.on(this.events.sessionChange, callback);
+    }
+
+    /**
+     * Restore an old session from storage and fallback to regular login
+     * @param json
+     * @param username
+     * @param password
+     * @returns {Promise<GarminConnect>}
+     */
+    async restoreOrLogin(json, username, password) {
+        return this.restore(json).catch((e) => {
+            console.warn(e);
+            return this.login(username, password);
+        });
+    }
+
+    /**
+     * Restore an old session from storage
+     * @param json
+     * @returns {Promise<GarminConnect>}
+     */
+    async restore(json) {
+        this.sessionJson = json;
+        try {
+            const info = await this.getUserInfo();
+            const { displayName } = info || {};
+            if (displayName && displayName === this.userHash) {
+                // Session restoration was successful
+                return this;
+            }
+            throw new Error('Unable to restore session, user hash do not match');
+        } catch (e) {
+            throw new Error(`Unable to restore session due to: ${e}`);
+        }
+    }
+
+    /**
+     * Login to Garmin Connect
+     * @param username
+     * @param password
+     * @returns {Promise<*>}
+     */
+    async login(username, password) {
+        let tempCredentials = { ...credentials, rememberme: 'on' };
+        if (username && password) {
+            tempCredentials = {
+                ...credentials, username, password, rememberme: 'on',
+            };
+        }
+        await this.client.get(urls.SIGNIN_URL);
+        await this.client.post(urls.SIGNIN_URL, tempCredentials);
+        const userPreferences = await this.getUserInfo();
+        const { displayName } = userPreferences;
+        this.userHash = displayName;
+        return this;
+    }
+
+    // User info
+    /**
+     * Get basic user information
+     * @returns {Promise<*>}
+     */
+    async getUserInfo() {
+        return this.get(urls.userInfo());
+    }
+
+    /**
+     * Get social user information
+     * @returns {Promise<*>}
+     */
+    async getSocialProfile() {
+        return this.get(urls.socialProfile(this.userHash));
+    }
+
+    /**
+     * Get a list of all social connections
+     * @returns {Promise<*>}
+     */
+    async getSocialConnections() {
+        return this.get(urls.socialConnections(this.userHash));
+    }
+
+    // Devices
+    /**
+     * Get a list of all registered devices
+     * @returns {Promise<*>}
+     */
+    async getDeviceInfo() {
+        return this.get(urls.deviceInfo(this.userHash));
+    }
+
+    // Sleep data
+    /**
+     * Get detailed sleep data for a specific date
+     * @param date
+     * @returns {Promise<*>}
+     */
+    async getSleepData(date = new Date()) {
+        const dateString = toDateString(date);
+        return this.get(urls.dailySleepData(this.userHash), { date: dateString });
+    }
+
+    /**
+     * Get sleep data summary for a specific date
+     * @param date
+     * @returns {Promise<*>}
+     */
+    async getSleep(date = new Date()) {
+        const dateString = toDateString(date);
+        return this.get(urls.dailySleep(), { date: dateString });
+    }
+
+    // Heart rate
+    /**
+     * Get heart rate measurements for a specific date
+     * @param date
+     * @returns {Promise<*>}
+     */
+    async getHeartRate(date = new Date()) {
+        const dateString = toDateString(date);
+        return this.get(urls.dailyHeartRate(this.userHash), { date: dateString });
+    }
+
+    // Weight
+    /**
+     * Post a new body weight
+     * @param weight
+     * @returns {Promise<*>}
+     */
+    async setBodyWeight(weight) {
+        if (weight) {
+            const roundWeight = Math.round(weight * 1000);
+            const data = { userData: { weight: roundWeight } };
+            return this.put(urls.userSettings(), data);
+        }
+        return Promise.reject();
+    }
+
+    // Activites
+    /**
+     * Get list of activites
+     * @param start
+     * @param limit
+     * @returns {Promise<*>}
+     */
+    async getActivities(start, limit) {
+        return this.get(urls.activities(), { start, limit });
+    }
+
+    /**
+     * Get details about an activity
+     * @param activity
+     * @param maxChartSize
+     * @param maxPolylineSize
+     * @returns {Promise<*>}
+     */
+    async getActivity(activity, maxChartSize, maxPolylineSize) {
+        const { activityId } = activity || {};
+        if (activityId) {
+            return this.get(urls.activityDetails(activityId), { maxChartSize, maxPolylineSize });
+        }
+        return Promise.reject();
+    }
+
+    /**
+     * Get weather data from an activity
+     * @param activity
+     * @returns {Promise<*>}
+     */
+    async getActivityWeather(activity) {
+        const { activityId } = activity || {};
+        if (activityId) {
+            return this.get(urls.weather(activityId));
+        }
+        return Promise.reject();
+    }
+
+    /**
+     * Updates an activity
+     * @param activity
+     * @returns {Promise<*>}
+     */
+    async updateActivity(activity) {
+        return this.put(urls.activity(activity.activityId), activity);
+    }
+
+    /**
+     * Deletes an activity
+     * @param activity
+     * @returns {Promise<*>}
+     */
+    async deleteActivity(activity) {
+        const { activityId } = activity || {};
+        if (activityId) {
+            const headers = { 'x-http-method-override': 'DELETE' };
+            return this.client.postJson(urls.activity(activityId), undefined, undefined, headers);
+        }
+        return Promise.reject();
+    }
+
+    /**
+     * Get list of activities in your news feed
+     * @param start
+     * @param limit
+     * @returns {Promise<*>}
+     */
+    async getNewsFeed(start, limit) {
+        return this.get(urls.newsFeed(), { start, limit });
+    }
+
+    // Steps
+    /**
+     * Get step count for a specific date
+     * @param date
+     * @returns {Promise<*>}
+     */
+    async getSteps(date = new Date()) {
+        const dateString = toDateString(date);
+        return this.get(urls.dailySummaryChart(this.userHash), { date: dateString });
+    }
+
+    // Workouts
+    /**
+     * Get list of workouts
+     * @param start
+     * @param limit
+     * @returns {Promise<*>}
+     */
+    async getWorkouts(start, limit) {
+        return this.get(urls.workouts(), { start, limit });
+    }
+
+    /**
+     * Download original activity data to disk as zip
+     * Resolves to absolute path for the downloaded file
+     * @param activity : any
+     * @param dir Will default to current working directory
+     * @param type : string - Will default to 'zip'. Other possible values are 'tcx', 'gpx' or 'kml'.
+     * @returns {Promise<*>}
+     */
+    async downloadOriginalActivityData(activity, dir, type = '') {
+        const { activityId } = activity || {};
+        if (activityId) {
+            const url = type === '' || type === 'zip'
+                ? urls.originalFile(activityId)
+                : urls.exportFile(activityId, type);
+            return this.client.downloadBlob(dir, url);
+        }
+        return Promise.reject();
+    }
+
+    /**
+     * Uploads an activity file ('gpx', 'tcx', or 'fit')
+     * @param file the file to upload
+     * @param format the format of the file. If undefined, the extension of the file will be used.
+     * @returns {Promise<*>}
+     */
+    async uploadActivity(file, format) {
+        // throw new Error('uploadActivity method is disabled in this version');
+
+        const detectedFormat = format || `.${file.split('.').pop()}`;
+        if (detectedFormat !== '.gpx' && detectedFormat !== '.tcx' && detectedFormat !== '.fit') {
+            Promise.reject();
+        }
+
+        const fileBinary = fs.createReadStream(file);
+        return this.client.post(urls.upload(format), {
+            file: fileBinary,
+        });
+    }
+
+    /**
+     * Adds a running workout with one step of completeing a set distance.
+     * @param name
+     * @param meters
+     * @param description
+     * @returns {Promise<*>}
+     */
+    async addRunningWorkout(name, meters, description) {
+        const running = new Running();
+        running.name = name;
+        running.distance = meters;
+        running.description = description;
+        return this.addWorkout(running);
+    }
+
+    /**
+     * Add a new workout preset.
+     * @param workout
+     * @returns {Promise<*>}
+     */
+    async addWorkout(workout) {
+        if (workout.isValid()) {
+            const data = { ...workout.toJson() };
+            if (!data.description) {
+                data.description = 'Added by garmin-connect for Node.js';
+            }
+            return this.post(urls.workout(), data);
+        }
+        return Promise.reject();
+    }
+
+    /**
+     * Add a workout to your workout calendar.
+     * @param workout
+     * @param date
+     * @returns {Promise<*>}
+     */
+    async scheduleWorkout(workout, date) {
+        const { workoutId } = workout || {};
+        if (workoutId && date) {
+            const dateString = toDateString(date);
+            return this.post(urls.schedule(workoutId), { date: dateString });
+        }
+        return Promise.reject();
+    }
+
+    /**
+     * Delete a workout based on a workout object.
+     * @param workout
+     * @returns {Promise<*>}
+     */
+    async deleteWorkout(workout) {
+        const { workoutId } = workout || {};
+        if (workoutId) {
+            const headers = { 'x-http-method-override': 'DELETE' };
+            return this.client.postJson(urls.workout(workoutId), undefined, undefined, headers);
+        }
+        return Promise.reject();
+    }
+
+    // General methods
+
+    async get(url, data) {
+        const response = await this.client.get(url, data);
+        this.triggerEvent(this.events.sessionChange, this.sessionJson);
+        return response;
+    }
+
+    async post(url, data) {
+        const response = await this.client.postJson(url, data);
+        this.triggerEvent(this.events.sessionChange, this.sessionJson);
+        return response;
+    }
+
+    async put(url, data) {
+        const response = await this.client.putJson(url, data);
+        this.triggerEvent(this.events.sessionChange, this.sessionJson);
+        return response;
+    }
+}
+
+module.exports = GarminConnect;

package/dist/garmin/Urls.js

@@ -0,0 +1,102 @@
+const GC_MODERN = 'https://connect.garmin.com/modern';
+const GARMIN_SSO_ORIGIN = 'https://sso.garmin.com';
+const GARMIN_SSO = `${GARMIN_SSO_ORIGIN}/sso`;
+const BASE_URL = `${GC_MODERN}/proxy`;
+const SIGNIN_URL = `${GARMIN_SSO}/signin`;
+const LOGIN_URL = `${GARMIN_SSO}/login`;
+
+const ACTIVITY_SERVICE = `${BASE_URL}/activity-service`;
+const ACTIVITYLIST_SERVICE = `${BASE_URL}/activitylist-service`;
+const CURRENT_USER_SERVICE = `${GC_MODERN}/currentuser-service/user/info`;
+const DEVICE_SERVICE = `${BASE_URL}/device-service`;
+const DOWNLOAD_SERVICE = `${BASE_URL}/download-service`;
+const USERPROFILE_SERVICE = `${BASE_URL}/userprofile-service`;
+const WELLNESS_SERVICE = `${BASE_URL}/wellness-service`;
+const WORKOUT_SERVICE = `${BASE_URL}/workout-service`;
+const UPLOAD_SERVICE = `${BASE_URL}/upload-service`;
+
+const USER_SETTINGS = `${USERPROFILE_SERVICE}/userprofile/user-settings/`;
+
+const activity = (id) => `${ACTIVITY_SERVICE}/activity/${id}`;
+
+const weather = (id) => `${activity(id)}/weather`;
+
+const activityDetails = (id) => `${activity(id)}/details`;
+
+const activities = () => `${ACTIVITYLIST_SERVICE}/activities/search/activities`;
+
+const dailyHeartRate = (userHash) => `${WELLNESS_SERVICE}/wellness/dailyHeartRate/${userHash}`;
+
+const dailySleep = () => `${WELLNESS_SERVICE}/wellness/dailySleep`;
+
+const dailySleepData = (userHash) => `${WELLNESS_SERVICE}/wellness/dailySleepData/${userHash}`;
+
+const dailySummaryChart = (userHash) => `${WELLNESS_SERVICE}/wellness/dailySummaryChart/${userHash}`;
+
+const deviceInfo = (userHash) => `${DEVICE_SERVICE}/deviceservice/device-info/all/${userHash}`;
+
+const schedule = (id) => `${WORKOUT_SERVICE}/schedule/${id}`;
+
+const userInfo = () => CURRENT_USER_SERVICE;
+
+const socialProfile = (userHash) => `${USERPROFILE_SERVICE}/socialProfile/${userHash}`;
+
+const userSettings = () => USER_SETTINGS;
+
+const originalFile = (id) => `${DOWNLOAD_SERVICE}/files/activity/${id}`;
+
+/**
+ *
+ * @param id {string}
+ * @param type "tcx" | "gpx" | "kml"
+ * @return {`${string}/export/${string}/activity/${string}`}
+ */
+const exportFile = (id, type) => `${DOWNLOAD_SERVICE}/export/${type}/activity/${id}`;
+
+const workout = (id) => {
+    if (id) {
+        return `${WORKOUT_SERVICE}/workout/${id}`;
+    }
+    return `${WORKOUT_SERVICE}/workout`;
+};
+
+const workouts = () => `${WORKOUT_SERVICE}/workouts`;
+
+const socialConnections = (userHash) => `${USERPROFILE_SERVICE}/socialProfile/connections/${userHash}`;
+
+const newsFeed = () => `${ACTIVITYLIST_SERVICE}/activities/subscriptionFeed`;
+
+const upload = (format) => `${UPLOAD_SERVICE}/upload/${format}`;
+
+module.exports = {
+    GC_MODERN,
+    GARMIN_SSO_ORIGIN,
+    GARMIN_SSO,
+    BASE_URL,
+    SIGNIN_URL,
+    LOGIN_URL,
+    CURRENT_USER_SERVICE,
+    USERPROFILE_SERVICE,
+    WELLNESS_SERVICE,
+    WORKOUT_SERVICE,
+    activity,
+    weather,
+    activityDetails,
+    activities,
+    dailyHeartRate,
+    dailySleep,
+    dailySleepData,
+    dailySummaryChart,
+    deviceInfo,
+    schedule,
+    userInfo,
+    socialProfile,
+    userSettings,
+    workout,
+    workouts,
+    originalFile,
+    exportFile,
+    socialConnections,
+    newsFeed,
+    upload,
+};

package/dist/garmin/workouts/Running.js

@@ -0,0 +1,53 @@
+const template = require('./templates/RunningTemplate');
+
+class Running {
+    constructor() {
+        this.data = template();
+    }
+
+    get name() {
+        return this.data.workoutName;
+    }
+
+    set name(name) {
+        this.data.workoutName = `${name}`;
+    }
+
+    get distance() {
+        return this.data.workoutSegments[0].workoutSteps[0].endConditionValue;
+    }
+
+    set distance(meters) {
+        this.data.workoutSegments[0].workoutSteps[0].endConditionValue = Math.round(meters);
+    }
+
+    get workoutId() {
+        return this.data.workoutId;
+    }
+
+    set workoutId(workoutId) {
+        this.data.workoutId = workoutId;
+    }
+
+    get description() {
+        return this.data.description;
+    }
+
+    set description(description) {
+        this.data.description = description;
+    }
+
+    isValid() {
+        return !!(this.name && this.distance);
+    }
+
+    toJson() {
+        return this.data;
+    }
+
+    toString() {
+        return `${this.name}, ${(this.distance / 1000).toFixed(2)}km`;
+    }
+}
+
+module.exports = Running;

package/dist/garmin/workouts/index.js

@@ -0,0 +1,5 @@
+const Running = require('./Running');
+
+module.exports = {
+    Running,
+};

package/dist/garmin/workouts/templates/RunningTemplate.js

@@ -0,0 +1,48 @@
+module.exports = () => (
+    {
+        sportType: {
+            sportTypeId: 1,
+            sportTypeKey: 'running',
+        },
+        workoutName: null,
+        workoutSegments: [
+            {
+                segmentOrder: 1,
+                sportType: {
+                    sportTypeId: 1,
+                    sportTypeKey: 'running',
+                },
+                workoutSteps: [
+                    {
+                        type: 'ExecutableStepDTO',
+                        stepId: null,
+                        stepOrder: 1,
+                        childStepId: null,
+                        description: null,
+                        stepType: {
+                            stepTypeId: 3,
+                            stepTypeKey: 'interval',
+                        },
+                        endCondition: {
+                            conditionTypeKey: 'distance',
+                            conditionTypeId: 3,
+                        },
+                        preferredEndConditionUnit: {
+                            unitKey: 'kilometer',
+                        },
+                        endConditionValue: null,
+                        endConditionCompare: null,
+                        endConditionZone: null,
+                        targetType: {
+                            workoutTargetTypeId: 1,
+                            workoutTargetTypeKey: 'no.target',
+                        },
+                        targetValueOne: null,
+                        targetValueTwo: null,
+                        zoneNumber: null,
+                    },
+                ],
+            },
+        ],
+    }
+);

package/dist/index.js

@@ -0,0 +1,3 @@
+const GarminConnect = require('./garmin/GarminConnect');
+
+module.exports = { GarminConnect };

package/examples/example.js

@@ -0,0 +1,19 @@
+const { GarminConnect } = require('garmin-connect');
+
+// Has to be run in an async function to be able to use the await keyword
+const main = async () => {
+    // Create a new Garmin Connect Client
+    const GCClient = new GarminConnect();
+
+    // Uses credentials from garmin.config.json or uses supplied params
+    await GCClient.login('my.email@example.com', 'MySecretPassword');
+
+    // Get user info
+    const info = await GCClient.getUserInfo();
+
+    // Log info to make sure signin was successful
+    console.log(info);
+};
+
+// Run the code
+main();

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@gooin/garmin-connect",
+  "version": "1.4.4",
+  "description": "Makes it simple to interface with Garmin Connect to get or set any data point",
+  "main": "./dist/index.js",
+  "scripts": {
+    "build": "rm -rf ./dist/ && mkdir ./dist/ && cp -r ./src/* ./dist/",
+    "prepack": "npm run build"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Pythe1337N/garmin-connect.git"
+  },
+  "keywords": [
+    "garmin",
+    "connect",
+    "scraper",
+    "weight",
+    "running",
+    "workout",
+    "activity",
+    "activities",
+    "download",
+    "downloader"
+  ],
+  "author": "Oskar Bernberg (Pythe1337N)",
+  "license": "MIT",
+  "files": [
+    "dist/*",
+    "examples/*"
+  ],
+  "devDependencies": {
+    "eslint": "^8.13.0",
+    "eslint-config-airbnb-base": "^15.0.0",
+    "eslint-plugin-import": "^2.26.0",
+    "eslint-plugin-jest": "^26.1.4",
+    "pre-commit": "^1.2.2"
+  },
+  "precommit": "build",
+  "homepage": "https://github.com/Pythe1337N/garmin-connect#readme",
+  "bugs": {
+    "url": "https://github.com/Pythe1337N/garmin-connect/issues"
+  },
+  "runkitExampleFilename": "./examples/example.js",
+  "dependencies": {
+    "app-root-path": "^3.0.0",
+    "axios": "^0.26.1",
+    "cloudscraper": "^4.6.0",
+    "form-data": "^4.0.0",
+    "qs": "^6.10.3",
+    "request": "^2.88.2"
+  }
+}