@artaio/node-api 0.27.0

package/dist/lib/endpoint/uploads.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UploadsEndpoint = void 0;
+var endpoint_1 = require("./endpoint");
+var UploadsEndpoint = /** @class */ (function () {
+    function UploadsEndpoint(artaClient) {
+        this.artaClient = artaClient;
+        this.path = '/uploads';
+        this.defaultEndpoint = new endpoint_1.DefaultEndpoint(this.path, this.artaClient);
+    }
+    UploadsEndpoint.prototype.getById = function (id, auth) {
+        return this.defaultEndpoint.getById(id, auth);
+    };
+    UploadsEndpoint.prototype.list = function (page, pageSize, auth) {
+        if (page === void 0) { page = 1; }
+        if (pageSize === void 0) { pageSize = 20; }
+        return this.defaultEndpoint.list({ page: page, page_size: pageSize }, auth);
+    };
+    UploadsEndpoint.prototype.create = function (payload, auth) {
+        return this.defaultEndpoint.create({ upload: payload }, auth);
+    };
+    UploadsEndpoint.prototype.remove = function (id, auth) {
+        return this.defaultEndpoint.remove(id, auth);
+    };
+    return UploadsEndpoint;
+}());
+exports.UploadsEndpoint = UploadsEndpoint;

package/dist/lib/endpoint/webhookDeliveries.d.ts

@@ -0,0 +1,26 @@
+import { ArtaID } from '../ArtaClient';
+import { WebhookDeliveryStatus, WebhookDeliveryType, WebhookResourceType } from '../MetadataTypes';
+import { RestClient } from '../net/RestClient';
+import { Page } from '../pagination';
+import { DatedInterface, NullableString } from '../utils';
+export interface WebhookDelivery extends DatedInterface {
+    id: ArtaID;
+    resource_id: number;
+    resource_type: WebhookResourceType;
+    response_status_code: number;
+    status: WebhookDeliveryStatus;
+    type: WebhookDeliveryType;
+    webhook_id: number;
+    webhook_url: string;
+    next_retry?: NullableString;
+    request_body?: NullableString;
+    response_body?: NullableString;
+}
+export declare class WebhookDeliveriesEndpoint {
+    private readonly artaClient;
+    private readonly defaultEndpoint;
+    private readonly path;
+    constructor(artaClient: RestClient);
+    getById(id: ArtaID, auth?: string): Promise<WebhookDelivery>;
+    list(page?: number, pageSize?: number, auth?: string): Promise<Page<WebhookDelivery>>;
+}

package/dist/lib/endpoint/webhookDeliveries.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebhookDeliveriesEndpoint = void 0;
+var endpoint_1 = require("./endpoint");
+var WebhookDeliveriesEndpoint = /** @class */ (function () {
+    function WebhookDeliveriesEndpoint(artaClient) {
+        this.artaClient = artaClient;
+        this.path = '/webhook_deliveries';
+        this.defaultEndpoint = new endpoint_1.DefaultEndpoint(this.path, this.artaClient);
+    }
+    WebhookDeliveriesEndpoint.prototype.getById = function (id, auth) {
+        return this.defaultEndpoint.getById(id, auth);
+    };
+    WebhookDeliveriesEndpoint.prototype.list = function (page, pageSize, auth) {
+        if (page === void 0) { page = 1; }
+        if (pageSize === void 0) { pageSize = 20; }
+        return this.defaultEndpoint.list({ page: page, page_size: pageSize }, auth);
+    };
+    return WebhookDeliveriesEndpoint;
+}());
+exports.WebhookDeliveriesEndpoint = WebhookDeliveriesEndpoint;

package/dist/lib/endpoint/webhooks.d.ts

@@ -0,0 +1,35 @@
+import { ArtaID } from '../ArtaClient';
+import { RestClient } from '../net/RestClient';
+import { DatedInterface } from '../utils';
+import { Page } from '../pagination';
+export interface Webhook extends DatedInterface {
+    id: ArtaID;
+    name: string;
+    url: string;
+    ping: (auth?: string) => Promise<void>;
+    getSecret: (auth?: string) => Promise<string>;
+    resetSecret: (auth?: string) => Promise<string>;
+}
+export interface WebhookCreateBody {
+    name: string;
+    url: string;
+}
+export interface WebhookCreate {
+    webhook: WebhookCreateBody;
+}
+export declare class WebhooksEndpoint {
+    private readonly artaClient;
+    private readonly defaultEndpoint;
+    private readonly path;
+    constructor(artaClient: RestClient);
+    private withFunctionCalls;
+    getById(id: ArtaID, auth?: string): Promise<Webhook>;
+    list(page?: number, pageSize?: number, auth?: string): Promise<Page<Webhook>>;
+    listAll(auth?: string): AsyncGenerator<Webhook>;
+    create(payload: WebhookCreateBody, auth?: string): Promise<Webhook>;
+    update(id: ArtaID, payload: Partial<WebhookCreateBody> | Partial<Webhook>, auth?: string): Promise<Webhook>;
+    remove(id: ArtaID, auth?: string): Promise<void>;
+    ping(id: ArtaID, auth?: string): Promise<void>;
+    getSecret(id: ArtaID, auth?: string): Promise<string>;
+    resetSecret(id: ArtaID, auth?: string): Promise<string>;
+}

package/dist/lib/endpoint/webhooks.js

@@ -0,0 +1,124 @@
+"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());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebhooksEndpoint = void 0;
+var endpoint_1 = require("./endpoint");
+var WebhooksEndpoint = /** @class */ (function () {
+    function WebhooksEndpoint(artaClient) {
+        this.artaClient = artaClient;
+        this.path = '/webhooks';
+        this.defaultEndpoint = new endpoint_1.DefaultEndpoint(this.path, this.artaClient, this.withFunctionCalls.bind(this));
+    }
+    WebhooksEndpoint.prototype.withFunctionCalls = function (webhook) {
+        var _this = this;
+        webhook.ping = function (auth) { return _this.ping(webhook.id, auth); };
+        webhook.getSecret = function (auth) { return _this.getSecret(webhook.id, auth); };
+        webhook.resetSecret = function (auth) { return _this.resetSecret(webhook.id, auth); };
+        return webhook;
+    };
+    WebhooksEndpoint.prototype.getById = function (id, auth) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.defaultEndpoint.getById(id, auth)];
+            });
+        });
+    };
+    WebhooksEndpoint.prototype.list = function (page, pageSize, auth) {
+        if (page === void 0) { page = 1; }
+        if (pageSize === void 0) { pageSize = 20; }
+        return this.defaultEndpoint.list({ page: page, page_size: pageSize }, auth);
+    };
+    WebhooksEndpoint.prototype.listAll = function (auth) {
+        return this.defaultEndpoint.listAll(auth);
+    };
+    WebhooksEndpoint.prototype.create = function (payload, auth) {
+        return this.defaultEndpoint.create({ webhook: payload }, auth);
+    };
+    WebhooksEndpoint.prototype.update = function (id, payload, auth) {
+        return __awaiter(this, void 0, void 0, function () {
+            var webhookUpdate;
+            return __generator(this, function (_a) {
+                webhookUpdate = { webhook: payload };
+                return [2 /*return*/, this.defaultEndpoint.update(id, webhookUpdate, auth)];
+            });
+        });
+    };
+    WebhooksEndpoint.prototype.remove = function (id, auth) {
+        return this.defaultEndpoint.remove(id, auth);
+    };
+    WebhooksEndpoint.prototype.ping = function (id, auth) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.artaClient.post("".concat(this.path, "/").concat(id, "/ping"), auth)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    WebhooksEndpoint.prototype.getSecret = function (id, auth) {
+        return __awaiter(this, void 0, void 0, function () {
+            var secret;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.artaClient.get("".concat(this.path, "/").concat(id, "/secret_token"), auth)];
+                    case 1:
+                        secret = _a.sent();
+                        return [2 /*return*/, secret.secret_token];
+                }
+            });
+        });
+    };
+    WebhooksEndpoint.prototype.resetSecret = function (id, auth) {
+        return __awaiter(this, void 0, void 0, function () {
+            var newSecret;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.artaClient.patch("".concat(this.path, "/").concat(id, "/secret_token/reset"), auth)];
+                    case 1:
+                        newSecret = _a.sent();
+                        return [2 /*return*/, newSecret.secret_token];
+                }
+            });
+        });
+    };
+    return WebhooksEndpoint;
+}());
+exports.WebhooksEndpoint = WebhooksEndpoint;

package/dist/lib/error.d.ts

@@ -0,0 +1,8 @@
+export interface ArtaAPIError {
+    errors: {
+        [key: string]: string | string[];
+    };
+}
+export declare class ArtaSDKError extends Error {
+    constructor(apiError: ArtaAPIError, status: number);
+}

package/dist/lib/error.js

@@ -0,0 +1,54 @@
+"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 });
+exports.ArtaSDKError = void 0;
+var parseArtaError = function (apiError) {
+    var formattedArtaError = '';
+    for (var _i = 0, _a = Object.keys(apiError.errors); _i < _a.length; _i++) {
+        var key = _a[_i];
+        if (key === 'detail') {
+            return "".concat(apiError.errors['detail'], ", ");
+        }
+        else if (Array.isArray(apiError.errors[key])) {
+            for (var _b = 0, _c = apiError.errors[key]; _b < _c.length; _b++) {
+                var error = _c[_b];
+                formattedArtaError += "".concat(key, " ").concat(error, ", ");
+            }
+        }
+        else {
+            formattedArtaError += "".concat(key, " ").concat(apiError.errors[key], ", ");
+        }
+    }
+    return formattedArtaError;
+};
+var ArtaSDKError = /** @class */ (function (_super) {
+    __extends(ArtaSDKError, _super);
+    function ArtaSDKError(apiError, status) {
+        var _this = this;
+        var keys = Object.keys(apiError.errors);
+        if (keys.length === 0) {
+            _this = _super.call(this, "Unknwon API error, HTTP status: ".concat(status)) || this;
+        }
+        else {
+            _this = _super.call(this, "".concat(parseArtaError(apiError), "HTTP status: ").concat(status)) || this;
+        }
+        Object.setPrototypeOf(_this, ArtaSDKError.prototype);
+        return _this;
+    }
+    return ArtaSDKError;
+}(Error));
+exports.ArtaSDKError = ArtaSDKError;

package/dist/lib/index.d.ts

@@ -0,0 +1,19 @@
+export { Arta } from './arta';
+export { Logger, LoggerVerbosity } from './logging';
+export { Attachment, AttachmentCreateBodyRequest, AttachmentCreateBodyShipment, AttachmentCreateBody, } from './endpoint/attachment';
+export { EmailRule, EmailRuleCreateBody } from './endpoint/emailRules';
+export { EmailSubscription, EmailSubscriptionCreateBody, } from './endpoint/emailSubscriptions';
+export { HostedSession, HostedSessionCreateBody, } from './endpoint/hostedSessions';
+export { InvoicePayment } from './endpoint/invoicePayments';
+export { Invoice } from './endpoint/invoices';
+export { Key, KeyCreateBody } from './endpoint/keys';
+export { Log } from './endpoint/logs';
+export * from './MetadataTypes';
+export { Organization } from './endpoint/organization';
+export { Payment } from './endpoint/payments';
+export { Upload, UploadCreateBody } from './endpoint/uploads';
+export { WebhookDelivery } from './endpoint/webhookDeliveries';
+export { Webhook, WebhookCreate } from './endpoint/webhooks';
+export { Tracking, TrackingEvent, Carrier } from './endpoint/trackings';
+export { Quote, QuoteRequest, QuoteRequestCreateBody, UpdateRequestsContactsBody, CustomQuotePayload, } from './endpoint/requests';
+export { Package, ShipmentSchedule, ShipmentTracking, Shipment, ShipmentCreateBody, } from './endpoint/shipments';

package/dist/lib/index.js

@@ -0,0 +1,20 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Arta = void 0;
+var arta_1 = require("./arta");
+Object.defineProperty(exports, "Arta", { enumerable: true, get: function () { return arta_1.Arta; } });
+__exportStar(require("./MetadataTypes"), exports);

package/dist/lib/logging.d.ts

@@ -0,0 +1,17 @@
+export interface Logger {
+    debug(message?: any, ...optionalParams: any[]): void;
+    info(message?: any, ...optionalParams: any[]): void;
+    warn(message?: any, ...optionalParams: any[]): void;
+    error(message?: any, ...optionalParams: any[]): void;
+}
+declare enum LogLevel {
+    NONE = 0,
+    ERROR = 1,
+    WARN = 2,
+    INFO = 3,
+    DEBUG = 4
+}
+export type LoggerVerbosity = keyof typeof LogLevel;
+export declare const initLogger: (logger: Logger, loggerVerbosity: LoggerVerbosity) => void;
+export declare const getLogger: () => Logger;
+export {};

package/dist/lib/logging.js

@@ -0,0 +1,79 @@
+"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));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLogger = exports.initLogger = void 0;
+var LogLevel;
+(function (LogLevel) {
+    LogLevel[LogLevel["NONE"] = 0] = "NONE";
+    LogLevel[LogLevel["ERROR"] = 1] = "ERROR";
+    LogLevel[LogLevel["WARN"] = 2] = "WARN";
+    LogLevel[LogLevel["INFO"] = 3] = "INFO";
+    LogLevel[LogLevel["DEBUG"] = 4] = "DEBUG";
+})(LogLevel || (LogLevel = {}));
+var LoggerWrapper = /** @class */ (function () {
+    function LoggerWrapper(logger, loggerVerbosity) {
+        this.logger = logger;
+        this.verbosity = LogLevel[loggerVerbosity];
+    }
+    LoggerWrapper.prototype.debug = function (message) {
+        var _a;
+        var optionalParams = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            optionalParams[_i - 1] = arguments[_i];
+        }
+        if (this.verbosity >= LogLevel.DEBUG) {
+            (_a = this.logger).debug.apply(_a, __spreadArray([message], optionalParams, false));
+        }
+    };
+    LoggerWrapper.prototype.info = function (message) {
+        var _a;
+        var optionalParams = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            optionalParams[_i - 1] = arguments[_i];
+        }
+        if (this.verbosity >= LogLevel.INFO) {
+            (_a = this.logger).info.apply(_a, __spreadArray([message], optionalParams, false));
+        }
+    };
+    LoggerWrapper.prototype.warn = function (message) {
+        var _a;
+        var optionalParams = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            optionalParams[_i - 1] = arguments[_i];
+        }
+        if (this.verbosity >= LogLevel.WARN) {
+            (_a = this.logger).warn.apply(_a, __spreadArray([message], optionalParams, false));
+        }
+    };
+    LoggerWrapper.prototype.error = function (message) {
+        var _a;
+        var optionalParams = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            optionalParams[_i - 1] = arguments[_i];
+        }
+        if (this.verbosity >= LogLevel.ERROR) {
+            (_a = this.logger).error.apply(_a, __spreadArray([message], optionalParams, false));
+        }
+    };
+    return LoggerWrapper;
+}());
+var _logger;
+var initLogger = function (logger, loggerVerbosity) {
+    _logger = new LoggerWrapper(logger, loggerVerbosity);
+};
+exports.initLogger = initLogger;
+var getLogger = function () {
+    if (!_logger) {
+        (0, exports.initLogger)(console, 'ERROR');
+    }
+    return _logger;
+};
+exports.getLogger = getLogger;

package/dist/lib/net/HttpClient.d.ts

@@ -0,0 +1,19 @@
+export type HttpMethod = 'get' | 'post' | 'patch' | 'put' | 'delete';
+export interface HttpClientResponse {
+    statusCode?: number;
+    headers?: any;
+    body: () => Promise<string>;
+    json: () => Promise<any>;
+}
+export interface HttpRequestParameters {
+    protocol: 'http' | 'https';
+    port: number;
+    path: string;
+    method: HttpMethod;
+    headers: any;
+    requestData: string;
+    timeout: number;
+}
+export interface HttpClient {
+    request: (host: string, params?: Partial<HttpRequestParameters>) => Promise<HttpClientResponse>;
+}

package/dist/lib/net/HttpClient.js

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

package/dist/lib/net/NodeHttpClient.d.ts

@@ -0,0 +1,20 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import * as http from 'http';
+import * as https from 'https';
+import { HttpClient, HttpClientResponse, HttpRequestParameters } from './HttpClient';
+export declare class NodeHttpClientResponse implements HttpClientResponse {
+    private readonly res;
+    statusCode?: number;
+    headers?: http.IncomingHttpHeaders;
+    private rawBody;
+    constructor(res: http.IncomingMessage);
+    body(): Promise<string>;
+    json(): Promise<any>;
+}
+export declare class NodeHttpClient implements HttpClient {
+    private readonly agent?;
+    private readonly logger;
+    constructor(agent?: http.Agent | https.Agent | undefined);
+    request(host: string, params?: Partial<HttpRequestParameters>): Promise<HttpClientResponse>;
+}