@internxt/sdk 1.4.76

package/dist/photos/users/index.js

@@ -0,0 +1,46 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var axios_1 = __importDefault(require("axios"));
+var utils_1 = require("../../utils");
+var UsersSubmodule = /** @class */ (function () {
+    function UsersSubmodule(model) {
+        this.model = model;
+    }
+    UsersSubmodule.prototype.initialize = function (data) {
+        var _this = this;
+        return axios_1.default
+            .post(this.model.baseUrl + "/users", {
+            mac: data.mac,
+            name: data.name,
+        }, {
+            headers: {
+                Authorization: "Bearer " + this.model.accessToken,
+                'internxt-network-pass': data.bridgePassword,
+                'internxt-network-user': data.bridgeUser,
+            },
+        })
+            .then(function (res) { return _this.parse(res.data); })
+            .catch(function (err) {
+            throw new Error((0, utils_1.extractAxiosErrorMessage)(err));
+        });
+    };
+    UsersSubmodule.prototype.parse = function (json) {
+        return __assign(__assign({}, json), { createdAt: new Date(json.createdAt), updatedAt: new Date(json.updatedAt) });
+    };
+    return UsersSubmodule;
+}());
+exports.default = UsersSubmodule;

package/dist/shared/headers/index.d.ts

@@ -0,0 +1,45 @@
+import { BasicAuth, Token } from '../../auth';
+export declare function basicHeaders(clientName: string, clientVersion: string): {
+    'content-type': string;
+    'internxt-version': string;
+    'internxt-client': string;
+};
+export declare function basicHeadersWithPassword(clientName: string, clientVersion: string, password: string): {
+    'content-type': string;
+    'internxt-version': string;
+    'internxt-client': string;
+    'x-share-password': string;
+};
+export declare function headersWithToken(clientName: string, clientVersion: string, token: Token): {
+    Authorization: string;
+    'content-type': string;
+    'internxt-version': string;
+    'internxt-client': string;
+};
+export declare function headersWithTokenAndMnemonic(clientName: string, clientVersion: string, token: Token, mnemonic: string): {
+    'internxt-mnemonic': string;
+    Authorization: string;
+    'content-type': string;
+    'internxt-version': string;
+    'internxt-client': string;
+};
+export declare function headersWithTokenAndMnemonicAndPassword(clientName: string, clientVersion: string, token: Token, mnemonic: string, password: string): {
+    'internxt-mnemonic': string;
+    'x-share-password': string;
+    Authorization: string;
+    'content-type': string;
+    'internxt-version': string;
+    'internxt-client': string;
+};
+export declare function headersWithBasicAuth(clientName: string, clientVersion: string, auth: BasicAuth): {
+    Authorization: string;
+    'content-type': string;
+    'internxt-version': string;
+    'internxt-client': string;
+};
+export declare function headersWithAuthToken(clientName: string, clientVersion: string, token: string): {
+    'x-token': string;
+    'content-type': string;
+    'internxt-version': string;
+    'internxt-client': string;
+};

package/dist/shared/headers/index.js

@@ -0,0 +1,71 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.headersWithAuthToken = exports.headersWithBasicAuth = exports.headersWithTokenAndMnemonicAndPassword = exports.headersWithTokenAndMnemonic = exports.headersWithToken = exports.basicHeadersWithPassword = exports.basicHeaders = void 0;
+function basicHeaders(clientName, clientVersion) {
+    return {
+        'content-type': 'application/json; charset=utf-8',
+        'internxt-version': clientVersion,
+        'internxt-client': clientName,
+    };
+}
+exports.basicHeaders = basicHeaders;
+function basicHeadersWithPassword(clientName, clientVersion, password) {
+    return {
+        'content-type': 'application/json; charset=utf-8',
+        'internxt-version': clientVersion,
+        'internxt-client': clientName,
+        'x-share-password': password,
+    };
+}
+exports.basicHeadersWithPassword = basicHeadersWithPassword;
+function headersWithToken(clientName, clientVersion, token) {
+    var headers = basicHeaders(clientName, clientVersion);
+    var extra = {
+        Authorization: 'Bearer ' + token,
+    };
+    return __assign(__assign({}, headers), extra);
+}
+exports.headersWithToken = headersWithToken;
+function headersWithTokenAndMnemonic(clientName, clientVersion, token, mnemonic) {
+    var headers = headersWithToken(clientName, clientVersion, token);
+    var extra = {
+        'internxt-mnemonic': mnemonic,
+    };
+    return __assign(__assign({}, headers), extra);
+}
+exports.headersWithTokenAndMnemonic = headersWithTokenAndMnemonic;
+function headersWithTokenAndMnemonicAndPassword(clientName, clientVersion, token, mnemonic, password) {
+    var headers = headersWithToken(clientName, clientVersion, token);
+    var extra = {
+        'internxt-mnemonic': mnemonic,
+        'x-share-password': password,
+    };
+    return __assign(__assign({}, headers), extra);
+}
+exports.headersWithTokenAndMnemonicAndPassword = headersWithTokenAndMnemonicAndPassword;
+function headersWithBasicAuth(clientName, clientVersion, auth) {
+    var headers = basicHeaders(clientName, clientVersion);
+    var token = auth.username + ":" + auth.password;
+    var encodedToken = Buffer.from(token).toString('base64');
+    var extra = {
+        Authorization: 'Basic ' + encodedToken,
+    };
+    return __assign(__assign({}, headers), extra);
+}
+exports.headersWithBasicAuth = headersWithBasicAuth;
+function headersWithAuthToken(clientName, clientVersion, token) {
+    var headers = basicHeaders(clientName, clientVersion);
+    return __assign(__assign({}, headers), { 'x-token': token });
+}
+exports.headersWithAuthToken = headersWithAuthToken;

package/dist/shared/http/client.d.ts

@@ -0,0 +1,78 @@
+import { Headers, URL, RequestCanceler, Parameters, UnauthorizedCallback } from './types';
+export { RequestCanceler } from './types';
+export declare class HttpClient {
+    private readonly axios;
+    private readonly unauthorizedCallback;
+    static create(baseURL: URL, unauthorizedCallback?: UnauthorizedCallback): HttpClient;
+    private constructor();
+    /**
+     * Requests a GET
+     * @param url
+     * @param headers
+     */
+    get<Response>(url: URL, headers: Headers): Promise<Response>;
+    /**
+     * Requests a GET with option to cancel
+     * @param url
+     * @param headers
+     */
+    getCancellable<Response>(url: URL, headers: Headers): {
+        promise: Promise<Response>;
+        requestCanceler: RequestCanceler;
+    };
+    /**
+     * Requests a POST
+     * @param url
+     * @param params
+     * @param headers
+     */
+    post<Response>(url: URL, params: Parameters, headers: Headers): Promise<Response>;
+    /**
+     * Requests a POST with option to cancel
+     * @param url
+     * @param params
+     * @param headers
+     */
+    postCancellable<Response>(url: URL, params: Parameters, headers: Headers): {
+        promise: Promise<Response>;
+        requestCanceler: RequestCanceler;
+    };
+    /**
+     * Requests PATCH
+     * @param url
+     * @param params
+     * @param headers
+     */
+    patch<Response>(url: URL, params: Parameters, headers: Headers): Promise<Response>;
+    /**
+     * Requests a PUT
+     * @param url
+     * @param params
+     * @param headers
+     */
+    put<Response>(url: URL, params: Parameters, headers: Headers): Promise<Response>;
+    /**
+     * Requests a DELETE
+     * @param url
+     * @param headers
+     * @param params
+     */
+    delete<Response>(url: URL, headers: Headers, params?: Parameters): Promise<Response>;
+    /**
+     * Sets middlewares into the client for common behaviour managing
+     * @private
+     */
+    private initializeMiddleware;
+    /**
+     * Extracts the valuable data from the server's response
+     * @param response
+     * @private
+     */
+    private static extractData;
+    /**
+     * Converts the specific client error into a proprietary error for our apps
+     * @param error
+     * @private
+     */
+    private normalizeError;
+}

package/dist/shared/http/client.js

@@ -0,0 +1,166 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpClient = void 0;
+var axios_1 = __importDefault(require("axios"));
+var errors_1 = __importDefault(require("../types/errors"));
+var HttpClient = /** @class */ (function () {
+    function HttpClient(baseURL, unauthorizedCallback) {
+        this.axios = axios_1.default.create({
+            baseURL: baseURL,
+        });
+        this.unauthorizedCallback = unauthorizedCallback;
+        this.initializeMiddleware();
+    }
+    HttpClient.create = function (baseURL, unauthorizedCallback) {
+        if (unauthorizedCallback === undefined) {
+            unauthorizedCallback = function () { return null; };
+        }
+        return new HttpClient(baseURL, unauthorizedCallback);
+    };
+    /**
+     * Requests a GET
+     * @param url
+     * @param headers
+     */
+    HttpClient.prototype.get = function (url, headers) {
+        return this.axios.get(url, {
+            headers: headers,
+        });
+    };
+    /**
+     * Requests a GET with option to cancel
+     * @param url
+     * @param headers
+     */
+    HttpClient.prototype.getCancellable = function (url, headers) {
+        var cancelTokenSource = axios_1.default.CancelToken.source();
+        var config = {
+            headers: headers,
+            cancelToken: cancelTokenSource.token,
+        };
+        var promise = this.axios.get(url, config);
+        return {
+            promise: promise,
+            requestCanceler: {
+                cancel: cancelTokenSource.cancel,
+            },
+        };
+    };
+    /**
+     * Requests a POST
+     * @param url
+     * @param params
+     * @param headers
+     */
+    HttpClient.prototype.post = function (url, params, headers) {
+        return this.axios.post(url, params, {
+            headers: headers,
+        });
+    };
+    /**
+     * Requests a POST with option to cancel
+     * @param url
+     * @param params
+     * @param headers
+     */
+    HttpClient.prototype.postCancellable = function (url, params, headers) {
+        var cancelTokenSource = axios_1.default.CancelToken.source();
+        var config = {
+            headers: headers,
+            cancelToken: cancelTokenSource.token,
+        };
+        var promise = this.axios.post(url, params, config);
+        return {
+            promise: promise,
+            requestCanceler: {
+                cancel: cancelTokenSource.cancel,
+            },
+        };
+    };
+    /**
+     * Requests PATCH
+     * @param url
+     * @param params
+     * @param headers
+     */
+    HttpClient.prototype.patch = function (url, params, headers) {
+        return this.axios.patch(url, params, {
+            headers: headers,
+        });
+    };
+    /**
+     * Requests a PUT
+     * @param url
+     * @param params
+     * @param headers
+     */
+    HttpClient.prototype.put = function (url, params, headers) {
+        return this.axios.put(url, params, {
+            headers: headers,
+        });
+    };
+    /**
+     * Requests a DELETE
+     * @param url
+     * @param headers
+     * @param params
+     */
+    HttpClient.prototype.delete = function (url, headers, params) {
+        return this.axios.delete(url, {
+            headers: headers,
+            data: params,
+        });
+    };
+    /**
+     * Sets middlewares into the client for common behaviour managing
+     * @private
+     */
+    HttpClient.prototype.initializeMiddleware = function () {
+        this.axios.interceptors.response.use(HttpClient.extractData, this.normalizeError.bind(this));
+    };
+    /**
+     * Extracts the valuable data from the server's response
+     * @param response
+     * @private
+     */
+    HttpClient.extractData = function (response) {
+        return response.data;
+    };
+    /**
+     * Converts the specific client error into a proprietary error for our apps
+     * @param error
+     * @private
+     */
+    HttpClient.prototype.normalizeError = function (error) {
+        var errorMessage, errorStatus;
+        if (error.response) {
+            var response = error.response;
+            if (response.status === 401) {
+                this.unauthorizedCallback();
+            }
+            if (response.data.error !== undefined) {
+                errorMessage = response.data.error;
+            }
+            else {
+                // TODO : remove when endpoints of updateMetadata(file/folder) are updated
+                // after all clients use th SDK
+                errorMessage = JSON.stringify(response.data);
+            }
+            errorStatus = response.status;
+        }
+        else if (error.request) {
+            errorMessage = 'Server unavailable';
+            errorStatus = 500;
+        }
+        else {
+            errorMessage = error.message;
+            errorStatus = 400;
+        }
+        throw new errors_1.default(errorMessage, errorStatus);
+    };
+    return HttpClient;
+}());
+exports.HttpClient = HttpClient;

package/dist/shared/http/types.d.ts

@@ -0,0 +1,7 @@
+export declare type URL = string;
+export declare type Headers = Record<string, string>;
+export declare type Parameters = Record<string, unknown> | FormData;
+export interface RequestCanceler {
+    cancel: (message?: string) => void;
+}
+export declare type UnauthorizedCallback = () => void;

package/dist/shared/http/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/shared/index.d.ts

@@ -0,0 +1 @@
+export * from './types/apiConnection';

package/dist/shared/index.js

@@ -0,0 +1,13 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types/apiConnection"), exports);

package/dist/shared/types/apiConnection.d.ts

@@ -0,0 +1,12 @@
+import { Token } from '../../auth';
+import { UnauthorizedCallback } from '../http/types';
+export declare type ApiUrl = string;
+export interface AppDetails {
+    clientName: string;
+    clientVersion: string;
+}
+export interface ApiSecurity {
+    token: Token;
+    mnemonic: string;
+    unauthorizedCallback?: UnauthorizedCallback;
+}

package/dist/shared/types/apiConnection.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/shared/types/appsumo.d.ts

@@ -0,0 +1,16 @@
+export interface AppSumoDetails {
+    createdAt: string;
+    id: number;
+    invoiceItemUuid: string;
+    planId: AppSumoTier;
+    updatedAt: '';
+    uuid: string;
+}
+export declare enum AppSumoTier {
+    Free = "internxt_free1",
+    Tier1 = "internxt_tier1",
+    Tier2 = "internxt_tier2",
+    Tier3 = "internxt_tier3",
+    Tier4 = "internxt_tier4",
+    Tier5 = "internxt_tier5"
+}

package/dist/shared/types/appsumo.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppSumoTier = void 0;
+var AppSumoTier;
+(function (AppSumoTier) {
+    AppSumoTier["Free"] = "internxt_free1";
+    AppSumoTier["Tier1"] = "internxt_tier1";
+    AppSumoTier["Tier2"] = "internxt_tier2";
+    AppSumoTier["Tier3"] = "internxt_tier3";
+    AppSumoTier["Tier4"] = "internxt_tier4";
+    AppSumoTier["Tier5"] = "internxt_tier5";
+})(AppSumoTier = exports.AppSumoTier || (exports.AppSumoTier = {}));

package/dist/shared/types/errors.d.ts

@@ -0,0 +1,4 @@
+export default class AppError extends Error {
+    readonly status?: number;
+    constructor(message: string, status?: number);
+}

package/dist/shared/types/errors.js

@@ -0,0 +1,27 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var AppError = /** @class */ (function (_super) {
+    __extends(AppError, _super);
+    function AppError(message, status) {
+        var _this = _super.call(this, message) || this;
+        _this.status = status;
+        return _this;
+    }
+    return AppError;
+}(Error));
+exports.default = AppError;

package/dist/shared/types/teams.d.ts

@@ -0,0 +1,9 @@
+export interface TeamsSettings {
+    isAdmin: boolean;
+    bucket: string;
+    bridge_mnemonic: string;
+    bridge_password: string;
+    bridge_user: string;
+    root_folder_id: number;
+    total_members: number;
+}

package/dist/shared/types/teams.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/shared/types/userSettings.d.ts

@@ -0,0 +1,27 @@
+import { AppSumoDetails } from './appsumo';
+export declare type UUID = string;
+export interface UserSettings {
+    userId: string;
+    uuid: UUID;
+    email: string;
+    name: string;
+    lastname: string;
+    username: string;
+    bridgeUser: string;
+    bucket: string;
+    backupsBucket: string | null;
+    root_folder_id: number;
+    sharedWorkspace: boolean;
+    credit: number;
+    mnemonic: string;
+    privateKey: string;
+    publicKey: string;
+    revocationKey: string;
+    teams?: boolean;
+    appSumoDetails: AppSumoDetails | null;
+    registerCompleted: boolean;
+    hasReferralsProgram: boolean;
+    createdAt: Date;
+    avatar: string | null;
+    emailVerified: boolean;
+}

package/dist/shared/types/userSettings.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils.d.ts

@@ -0,0 +1,3 @@
+import { AxiosError } from 'axios';
+export declare function extractAxiosErrorMessage(err: AxiosError): string;
+export declare function isHexString(string: string): boolean;

package/dist/utils.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isHexString = exports.extractAxiosErrorMessage = void 0;
+function extractAxiosErrorMessage(err) {
+    var errMsg;
+    var error = err;
+    var isServerError = !!error.response;
+    var serverUnavailable = !!error.request;
+    if (isServerError) {
+        errMsg = error.response.data.error;
+    }
+    else if (serverUnavailable) {
+        errMsg = 'Server not available';
+    }
+    else {
+        errMsg = error.message;
+    }
+    return errMsg;
+}
+exports.extractAxiosErrorMessage = extractAxiosErrorMessage;
+function isHexString(string) {
+    // TODO: replace with proper library
+    return /^([0-9a-fA-F]{2})+$/.test(string);
+}
+exports.isHexString = isHexString;

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@internxt/sdk",
+  "version": "1.4.76",
+  "description": "An sdk for interacting with Internxt's services",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/internxt/sdk.git"
+  },
+  "author": "",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/internxt/sdk/issues"
+  },
+  "homepage": "https://github.com/internxt/sdk#readme",
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "prepare": "husky install",
+    "test": "jest --detectOpenHandles test/",
+    "test:cov": "jest --coverage",
+    "build": "tsc",
+    "lint": "eslint src/**/*.ts --max-warnings=0",
+    "format": "prettier src/**/*.ts"
+  },
+  "devDependencies": {
+    "@internxt/eslint-config-internxt": "^1.0.3",
+    "@internxt/prettier-config": "^1.0.1",
+    "@types/jest": "^27.0.1",
+    "@types/sinon": "^10.0.6",
+    "@types/uuid": "^8.3.4",
+    "eslint": "^7.32.0",
+    "husky": "^7.0.1",
+    "jest": "^27.0.6",
+    "prettier": "^2.3.2",
+    "sinon": "^12.0.1",
+    "ts-jest": "^27.0.5",
+    "typescript": "^4.3.5"
+  },
+  "dependencies": {
+    "axios": "^0.24.0",
+    "query-string": "^7.1.0",
+    "uuid": "^8.3.2"
+  },
+  "directories": {
+    "test": "test"
+  }
+}