@datastrata/ds-object-storage/lib/index.js

## dev environment setup instructions https://itnext.io/step-by-step-building-and-publishing-an-npm-typescript-package-44fe7164964c

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.DsObjectStorage = void 0;
const got_1 = require("got");
const FormData = require("form-data");
class DsObjectStorage {
    constructor(clientId, clientSecret) {
        this.DATASTRATA_ENDPOINT = (process.env.DATASTRATA_ENDPOINT ? process.env.DATASTRATA_ENDPOINT : 'https://app.datastrata.io') + '/ds/records/';
        this.DATASTRATA_DOCS_AUTH0_DOMAIN = process.env.DATASTRATA_DOCS_AUTH0_DOMAIN
            ? process.env.DATASTRATA_DOCS_AUTH0_DOMAIN
            : 'docs-datastrata.us.auth0.com';
        this.clientId = clientId;
        this.clientSecret = clientSecret;
    }
    putObject(params) {
        return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
            try {
                const url = this.DATASTRATA_ENDPOINT + 'putObject';
                const form = new FormData();
                Object.keys(params).forEach((key, index) => {
                    form.append(key, params[key]);
                });
                const token = yield this.getRestCredentialToken();
                const headers = {
                    authorization: 'Bearer ' + token.access_token,
                };
                const { body } = yield got_1.default(url, {
                    method: 'POST',
                    headers: Object.assign(Object.assign({}, form.getHeaders()), headers),
                    body: form,
                });
                const jsonBody = JSON.parse(body);
                return resolve(jsonBody);
            }
            catch (err) {
                return reject(err);
            }
        }));
    }
    getObject(params) {
        return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
            try {
                const url = this.DATASTRATA_ENDPOINT + 'getObject';
                const result = yield this.httpRequest(url, params);
                result.Body = Buffer.from(result.Body.data);
                return resolve(result);
            }
            catch (err) {
                return reject(err);
            }
        }));
    }
    deleteObject(params) {
        return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
            try {
                const url = this.DATASTRATA_ENDPOINT + 'deleteObject';
                const result = yield this.httpRequest(url, params);
                return resolve(result);
            }
            catch (err) {
                return reject(err);
            }
        }));
    }
    listObjects(params) {
        return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
            try {
                const url = this.DATASTRATA_ENDPOINT + 'listObjects';
                const result = yield this.httpRequest(url, params);
                return resolve(result);
            }
            catch (err) {
                return reject(err);
            }
        }));
    }
    listObjectsV2(params) {
        return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
            try {
                const url = this.DATASTRATA_ENDPOINT + 'listObjectsV2';
                const result = yield this.httpRequest(url, params);
                return resolve(result);
            }
            catch (err) {
                return reject(err);
            }
        }));
    }
    httpRequest(url, body) {
        return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
            try {
                const token = yield this.getRestCredentialToken();
                const headers = {
                    'content-type': 'application/json',
                    authorization: 'Bearer ' + token.access_token,
                };
                const response = yield got_1.default.post(url, {
                    headers: headers,
                    json: body,
                    responseType: 'json',
                });
                if (response.statusCode && response.statusCode !== 200) {
                    return reject(body);
                }
                return resolve(response.body);
            }
            catch (err) {
                return reject(err);
            }
        }));
    }
    getRestCredentialToken() {
        return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
            try {
                if (this.dsToken) {
                    if (Date.now() - this.dsTokenDateTime < 600000) {
                        return resolve(this.dsToken);
                    }
                }
                const url = 'https://' + this.DATASTRATA_DOCS_AUTH0_DOMAIN + '/oauth/token';
                const response = yield got_1.default.post(url, {
                    headers: { 'content-type': 'application/json' },
                    json: {
                        client_id: this.clientId,
                        client_secret: this.clientSecret,
                        audience: 'https://docs.datastrata.io/',
                        grant_type: 'client_credentials',
                    },
                    responseType: 'json',
                });
                if ('statusCode' in response && response.statusCode !== 200) {
                    // @ts-ignore
                    const e = new Error('Auth0 Error: ' + response.body.error_description);
                    return reject(e);
                }
                this.dsTokenDateTime = Date.now();
                this.dsToken = response.body;
                return resolve(response.body);
            }
            catch (err) {
                if (this.dsToken) {
                    return resolve(this.dsToken);
                }
                else {
                    return reject(err);
                }
            }
        }));
    }
}
exports.DsObjectStorage = DsObjectStorage;