@hubspot/local-dev-lib 0.0.1-experimental.0

package/enums/build.d.ts

@@ -0,0 +1,36 @@
+export declare const BUILD_STATUS: {
+    readonly BUILDING: "BUILDING";
+    readonly FAILURE: "FAILURE";
+    readonly PREPARING: "PREPARING";
+    readonly PENDING: "PENDING";
+    readonly SUCCESS: "SUCCESS";
+};
+export declare const SUBBUILD_TYPES: {
+    readonly APP: "APP";
+    readonly PRIVATE_APP: "PRIVATE_APP";
+    readonly THEME: "THEME";
+    readonly REACT_THEME: "REACT_THEME";
+    readonly NO_SUBBUILDS: "NO_SUBBUILDS";
+};
+export declare const DEPLOYABLE_STATES: {
+    DEPLOYABLE: string;
+    DEPRECATED: string;
+};
+export declare const COMPONENT_TYPES: {
+    readonly APP: "APP";
+    readonly PRIVATE_APP: "PRIVATE_APP";
+    readonly THEME: "THEME";
+    readonly REACT_THEME: "REACT_THEME";
+};
+export declare const SUBCOMPONENT_TYPES: {
+    readonly APP_ID: "APP_ID";
+    readonly PACKAGE_LOCK_FILE: "PACKAGE_LOCK_FILE";
+    readonly CRM_CARD_V2: "CRM_CARD_V2";
+    readonly CARD_V2: "CARD_V2";
+    readonly SERVERLESS_PKG: "SERVERLESS_PKG";
+    readonly SERVERLESS_ROUTE: "SERVERLESS_ROUTE";
+    readonly SERVERLESS_FUNCTION: "SERVERLESS_FUNCTION";
+    readonly APP_FUNCTION: "APP_FUNCTION";
+    readonly AUTOMATION_ACTION: "AUTOMATION_ACTION";
+    readonly REACT_EXTENSION: "REACT_EXTENSION";
+};

package/enums/build.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SUBCOMPONENT_TYPES = exports.COMPONENT_TYPES = exports.DEPLOYABLE_STATES = exports.SUBBUILD_TYPES = exports.BUILD_STATUS = void 0;
+exports.BUILD_STATUS = {
+    BUILDING: 'BUILDING',
+    FAILURE: 'FAILURE',
+    PREPARING: 'PREPARING',
+    PENDING: 'PENDING',
+    SUCCESS: 'SUCCESS',
+};
+exports.SUBBUILD_TYPES = {
+    APP: 'APP',
+    PRIVATE_APP: 'PRIVATE_APP',
+    THEME: 'THEME',
+    REACT_THEME: 'REACT_THEME',
+    NO_SUBBUILDS: 'NO_SUBBUILDS',
+};
+exports.DEPLOYABLE_STATES = {
+    DEPLOYABLE: 'DEPLOYABLE',
+    DEPRECATED: 'DEPRECATED_APP_NON_SUBCOMPONENT',
+};
+exports.COMPONENT_TYPES = {
+    APP: 'APP',
+    PRIVATE_APP: 'PRIVATE_APP',
+    THEME: 'THEME',
+    REACT_THEME: 'REACT_THEME',
+};
+exports.SUBCOMPONENT_TYPES = {
+    APP_ID: 'APP_ID',
+    PACKAGE_LOCK_FILE: 'PACKAGE_LOCK_FILE',
+    CRM_CARD_V2: 'CRM_CARD_V2',
+    CARD_V2: 'CARD_V2',
+    SERVERLESS_PKG: 'SERVERLESS_PKG',
+    SERVERLESS_ROUTE: 'SERVERLESS_ROUTE',
+    SERVERLESS_FUNCTION: 'SERVERLESS_FUNCTION',
+    APP_FUNCTION: 'APP_FUNCTION',
+    AUTOMATION_ACTION: 'AUTOMATION_ACTION',
+    REACT_EXTENSION: 'REACT_EXTENSION',
+};

package/enums/deploy.d.ts

@@ -0,0 +1,11 @@
+export declare const DEPLOY_STATUS: {
+    readonly DEPLOYING: "DEPLOYING";
+    readonly FAILURE: "FAILURE";
+    readonly PENDING: "PENDING";
+    readonly SUCCESS: "SUCCESS";
+    readonly FINISHED: "FINISHED";
+};
+export declare const DEPLOY_ACTION: {
+    REMOVE: string;
+    INSTALL: string;
+};

package/enums/deploy.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEPLOY_ACTION = exports.DEPLOY_STATUS = void 0;
+exports.DEPLOY_STATUS = {
+    DEPLOYING: 'DEPLOYING',
+    FAILURE: 'FAILURE',
+    PENDING: 'PENDING',
+    SUCCESS: 'SUCCESS',
+    FINISHED: 'FINISHED',
+};
+exports.DEPLOY_ACTION = {
+    REMOVE: 'REMOVE',
+    INSTALL: 'INSTALL',
+};

package/enums/project.d.ts

@@ -0,0 +1,6 @@
+export declare const ACTIVITY_SOURCE: {
+    readonly GITHUB_USER: "GITHUB_USER";
+    readonly HUBSPOT: "HUBSPOT";
+    readonly HUBSPOT_USER: "HUBSPOT_USER";
+    readonly DEPRECATED_AUTO_UNDEPLOY: "DEPRECATED_AUTO_UNDEPLOY";
+};

package/enums/project.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ACTIVITY_SOURCE = void 0;
+exports.ACTIVITY_SOURCE = {
+    GITHUB_USER: 'GITHUB_USER',
+    HUBSPOT: 'HUBSPOT',
+    HUBSPOT_USER: 'HUBSPOT_USER',
+    DEPRECATED_AUTO_UNDEPLOY: 'DEPRECATED_AUTO_UNDEPLOY',
+};

package/errors/errors_DEPRECATED.d.ts

@@ -0,0 +1,3 @@
+import { BaseError, FileSystemErrorContext, ErrorContext } from '../types/Error';
+export declare function logErrorInstance(error: BaseError, context?: ErrorContext): void;
+export declare function logFileSystemErrorInstance(error: BaseError, context: FileSystemErrorContext): void;

package/errors/errors_DEPRECATED.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logFileSystemErrorInstance = exports.logErrorInstance = void 0;
+function isSystemError(err) {
+    return err.errno != null && err.code != null && err.syscall != null;
+}
+function debugErrorAndContext(error, context) {
+    console.debug('Error: %o', error);
+    console.debug('Context: %o', context);
+}
+function logErrorInstance(error, context) {
+    // SystemError
+    if (isSystemError(error)) {
+        console.error(`A system error has occurred: ${error.message}`);
+        debugErrorAndContext(error, context);
+        return;
+    }
+    if (error instanceof Error ||
+        error.message ||
+        error.reason) {
+        // Error or Error subclass
+        const name = error.name || 'Error';
+        const message = [`A ${name} has occurred.`];
+        [error.message, error.reason].forEach(msg => {
+            if (msg) {
+                message.push(msg);
+            }
+        });
+        console.error(message.join(' '));
+    }
+    else {
+        // Unknown errors
+        console.error(`An unknown error has occurred.`);
+    }
+    debugErrorAndContext(error, context);
+}
+exports.logErrorInstance = logErrorInstance;
+function logFileSystemErrorInstance(error, context) {
+    let fileAction = '';
+    if (context.operation === 'read') {
+        fileAction = 'reading from';
+    }
+    else if (context.operation === 'write') {
+        fileAction = 'writing to';
+    }
+    else {
+        fileAction = 'accessing';
+    }
+    const filepath = context.filepath
+        ? `"${context.filepath}"`
+        : 'a file or folder';
+    const message = [`An error occurred while ${fileAction} ${filepath}.`];
+    // Many `fs` errors will be `SystemError`s
+    if (isSystemError(error)) {
+        message.push(`This is the result of a system error: ${error.message}`);
+    }
+    console.error(message.join(' '));
+    debugErrorAndContext(error, context);
+}
+exports.logFileSystemErrorInstance = logFileSystemErrorInstance;

package/errors/index.d.ts

@@ -0,0 +1,18 @@
+import { HubSpotHttpError } from '../models/HubSpotHttpError';
+import { BaseError } from '../types/Error';
+import { FileSystemError } from '../models/FileSystemError';
+export declare function isSpecifiedError(err: unknown, { statusCode, category, subCategory, errorType, code, }: {
+    statusCode?: number;
+    category?: string;
+    subCategory?: string;
+    errorType?: string;
+    code?: string;
+}): err is HubSpotHttpError;
+export declare function isMissingScopeError(err: unknown): err is HubSpotHttpError;
+export declare function isGatingError(err: unknown): err is HubSpotHttpError;
+export declare function isTimeoutError(err: unknown): err is HubSpotHttpError;
+export declare function isAuthError(err: unknown): err is HubSpotHttpError;
+export declare function isValidationError(err: unknown): boolean;
+export declare function isHubSpotHttpError(error?: unknown): error is HubSpotHttpError;
+export declare function isSystemError(err: unknown): err is BaseError;
+export declare function isFileSystemError(err: unknown): err is FileSystemError;

package/errors/index.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isFileSystemError = exports.isSystemError = exports.isHubSpotHttpError = exports.isValidationError = exports.isAuthError = exports.isTimeoutError = exports.isGatingError = exports.isMissingScopeError = exports.isSpecifiedError = void 0;
+const HubSpotHttpError_1 = require("../models/HubSpotHttpError");
+const FileSystemError_1 = require("../models/FileSystemError");
+function isSpecifiedError(err, { statusCode, category, subCategory, errorType, code, }) {
+    if (!isHubSpotHttpError(err)) {
+        return false;
+    }
+    const { data, status, code: actualCode } = err;
+    const statusCodeMatchesError = !statusCode || status === statusCode;
+    const categoryMatchesError = !category || data?.category === category;
+    const subCategoryMatchesError = !subCategory || data?.subCategory === subCategory;
+    const errorTypeMatchesError = !errorType || data?.errorType === errorType;
+    const codeMatchesError = !code || actualCode === code;
+    return (statusCodeMatchesError &&
+        categoryMatchesError &&
+        subCategoryMatchesError &&
+        errorTypeMatchesError &&
+        codeMatchesError);
+}
+exports.isSpecifiedError = isSpecifiedError;
+function isMissingScopeError(err) {
+    return isSpecifiedError(err, { statusCode: 403, category: 'MISSING_SCOPES' });
+}
+exports.isMissingScopeError = isMissingScopeError;
+function isGatingError(err) {
+    return isSpecifiedError(err, { statusCode: 403, category: 'GATED' });
+}
+exports.isGatingError = isGatingError;
+function isTimeoutError(err) {
+    return isSpecifiedError(err, { code: 'ETIMEDOUT' });
+}
+exports.isTimeoutError = isTimeoutError;
+function isAuthError(err) {
+    return (isSpecifiedError(err, { statusCode: 401 }) ||
+        isSpecifiedError(err, { statusCode: 403 }));
+}
+exports.isAuthError = isAuthError;
+function isValidationError(err) {
+    return (isHubSpotHttpError(err) &&
+        isSpecifiedError(err, { statusCode: 400 }) &&
+        !!(err?.data?.message || !!err.data?.errors));
+}
+exports.isValidationError = isValidationError;
+function isHubSpotHttpError(error) {
+    return !!error && error instanceof HubSpotHttpError_1.HubSpotHttpError;
+}
+exports.isHubSpotHttpError = isHubSpotHttpError;
+function isSystemError(err) {
+    return (err instanceof Error &&
+        'errno' in err &&
+        err.errno != null &&
+        'code' in err &&
+        err.code != null &&
+        'syscall' in err &&
+        err.syscall != null);
+}
+exports.isSystemError = isSystemError;
+function isFileSystemError(err) {
+    return err instanceof FileSystemError_1.FileSystemError;
+}
+exports.isFileSystemError = isFileSystemError;

package/http/addQueryParams.d.ts

@@ -0,0 +1,2 @@
+import { HttpOptions, QueryParams } from '../types/Http';
+export declare function addQueryParams(configOptions: HttpOptions, queryParams?: QueryParams): HttpOptions;

package/http/addQueryParams.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addQueryParams = void 0;
+function addQueryParams(configOptions, queryParams = {}) {
+    const { params } = configOptions;
+    return {
+        ...configOptions,
+        params: {
+            ...queryParams,
+            ...params,
+        },
+    };
+}
+exports.addQueryParams = addQueryParams;

package/http/getAxiosConfig.d.ts

@@ -0,0 +1,9 @@
+import { HttpOptions } from '../types/Http';
+import { AxiosRequestConfig } from 'axios';
+export declare const USER_AGENTS: {
+    [key: string]: string;
+};
+export declare function getDefaultUserAgentHeader(): {
+    'User-Agent': string;
+};
+export declare function getAxiosConfig(options: HttpOptions): AxiosRequestConfig;

package/http/getAxiosConfig.js

@@ -0,0 +1,66 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAxiosConfig = exports.getDefaultUserAgentHeader = exports.USER_AGENTS = void 0;
+const package_json_1 = require("../package.json");
+const config_1 = require("../config");
+const urls_1 = require("../lib/urls");
+const https_1 = __importDefault(require("https"));
+const http_1 = __importDefault(require("http"));
+// Total number of sockets across all hosts
+const MAX_TOTAL_SOCKETS = 25;
+// Total number of sockets per each host
+const MAX_SOCKETS_PER_HOST = 5;
+const httpAgent = new http_1.default.Agent({
+    keepAlive: true,
+    maxTotalSockets: MAX_TOTAL_SOCKETS,
+    maxSockets: MAX_SOCKETS_PER_HOST,
+});
+const httpsAgent = new https_1.default.Agent({
+    keepAlive: true,
+    maxTotalSockets: MAX_TOTAL_SOCKETS,
+    maxSockets: MAX_SOCKETS_PER_HOST,
+});
+exports.USER_AGENTS = {
+    'HubSpot Local Dev Lib': package_json_1.version,
+};
+function getDefaultUserAgentHeader() {
+    let userAgentString = '';
+    Object.keys(exports.USER_AGENTS).forEach((userAgentKey, i) => {
+        userAgentString += `${i > 0 ? ', ' : ''}${userAgentKey}/${exports.USER_AGENTS[userAgentKey]}`;
+    });
+    return {
+        'User-Agent': userAgentString,
+    };
+}
+exports.getDefaultUserAgentHeader = getDefaultUserAgentHeader;
+const DEFAULT_TRANSITIONAL = {
+    clarifyTimeoutError: true,
+};
+function getAxiosConfig(options) {
+    const { env, localHostOverride, headers, ...rest } = options;
+    const config = (0, config_1.getAndLoadConfigIfNeeded)();
+    let httpTimeout = 15000;
+    let httpUseLocalhost = false;
+    if (config && config.httpTimeout) {
+        httpTimeout = config.httpTimeout;
+    }
+    if (config && config.httpUseLocalhost) {
+        httpUseLocalhost = config.httpUseLocalhost;
+    }
+    return {
+        baseURL: (0, urls_1.getHubSpotApiOrigin)(env, localHostOverride ? false : httpUseLocalhost),
+        headers: {
+            ...getDefaultUserAgentHeader(),
+            ...(headers || {}),
+        },
+        timeout: httpTimeout,
+        transitional: DEFAULT_TRANSITIONAL,
+        httpAgent,
+        httpsAgent,
+        ...rest,
+    };
+}
+exports.getAxiosConfig = getAxiosConfig;

package/http/index.d.ts

@@ -0,0 +1,17 @@
+import { AxiosPromise } from 'axios';
+import { HttpOptions } from '../types/Http';
+export declare function addUserAgentHeader(key: string, value: string): void;
+declare function getRequest<T>(accountId: number, options: HttpOptions): AxiosPromise<T>;
+declare function postRequest<T>(accountId: number, options: HttpOptions): AxiosPromise<T>;
+declare function putRequest<T>(accountId: number, options: HttpOptions): AxiosPromise<T>;
+declare function patchRequest<T>(accountId: number, options: HttpOptions): AxiosPromise<T>;
+declare function deleteRequest<T>(accountId: number, options: HttpOptions): AxiosPromise<T>;
+export declare const http: {
+    get: typeof getRequest;
+    post: typeof postRequest;
+    put: typeof putRequest;
+    patch: typeof patchRequest;
+    delete: typeof deleteRequest;
+    getOctetStream: (accountId: number, options: HttpOptions, destPath: string) => AxiosPromise<any>;
+};
+export {};

package/http/index.js

@@ -0,0 +1,173 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.http = exports.addUserAgentHeader = void 0;
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const content_disposition_1 = __importDefault(require("content-disposition"));
+const axios_1 = __importDefault(require("axios"));
+const config_1 = require("../config");
+const getAxiosConfig_1 = require("./getAxiosConfig");
+const addQueryParams_1 = require("./addQueryParams");
+const personalAccessKey_1 = require("../lib/personalAccessKey");
+const oauth_1 = require("../lib/oauth");
+const logger_1 = require("../lib/logger");
+const lang_1 = require("../utils/lang");
+const HubSpotHttpError_1 = require("../models/HubSpotHttpError");
+const i18nKey = 'http.index';
+axios_1.default.interceptors.response.use(undefined, error => {
+    // Wrap all axios errors in our own Error class.  Attach the error
+    // as the cause for the new error, so we maintain the stack trace
+    return Promise.reject(new HubSpotHttpError_1.HubSpotHttpError(error.message, { cause: error }));
+});
+function addUserAgentHeader(key, value) {
+    getAxiosConfig_1.USER_AGENTS[key] = value;
+}
+exports.addUserAgentHeader = addUserAgentHeader;
+async function withOauth(accountId, accountConfig, axiosConfig) {
+    const { headers } = axiosConfig;
+    const oauth = (0, oauth_1.getOauthManager)(accountId, accountConfig);
+    if (!oauth) {
+        throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.withOauth`, { accountId }));
+    }
+    const accessToken = await oauth.accessToken();
+    return {
+        ...axiosConfig,
+        headers: {
+            ...headers,
+            Authorization: `Bearer ${accessToken}`,
+        },
+    };
+}
+async function withPersonalAccessKey(accountId, axiosConfig) {
+    const { headers } = axiosConfig;
+    const accessToken = await (0, personalAccessKey_1.accessTokenForPersonalAccessKey)(accountId);
+    return {
+        ...axiosConfig,
+        headers: {
+            ...headers,
+            Authorization: `Bearer ${accessToken}`,
+        },
+    };
+}
+function withPortalId(portalId, axiosConfig) {
+    const { params } = axiosConfig;
+    return {
+        ...axiosConfig,
+        params: {
+            ...params,
+            portalId,
+        },
+    };
+}
+async function withAuth(accountId, options) {
+    const accountConfig = (0, config_1.getAccountConfig)(accountId);
+    if (!accountConfig) {
+        throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.withAuth`, { accountId }));
+    }
+    const { env, authType, apiKey } = accountConfig;
+    const axiosConfig = withPortalId(accountId, (0, getAxiosConfig_1.getAxiosConfig)({ env, ...options }));
+    if (authType === 'personalaccesskey') {
+        return withPersonalAccessKey(accountId, axiosConfig);
+    }
+    if (authType === 'oauth2') {
+        return withOauth(accountId, accountConfig, axiosConfig);
+    }
+    const { params } = axiosConfig;
+    return {
+        ...axiosConfig,
+        params: {
+            ...params,
+            hapikey: apiKey,
+        },
+    };
+}
+async function getRequest(accountId, options) {
+    const { params, ...rest } = options;
+    const optionsWithParams = (0, addQueryParams_1.addQueryParams)(rest, params);
+    const requestConfig = await withAuth(accountId, optionsWithParams);
+    return (0, axios_1.default)(requestConfig);
+}
+async function postRequest(accountId, options) {
+    const requestConfig = await withAuth(accountId, options);
+    return (0, axios_1.default)({ ...requestConfig, method: 'post' });
+}
+async function putRequest(accountId, options) {
+    const requestConfig = await withAuth(accountId, options);
+    return (0, axios_1.default)({ ...requestConfig, method: 'put' });
+}
+async function patchRequest(accountId, options) {
+    const requestConfig = await withAuth(accountId, options);
+    return (0, axios_1.default)({ ...requestConfig, method: 'patch' });
+}
+async function deleteRequest(accountId, options) {
+    const requestConfig = await withAuth(accountId, options);
+    return (0, axios_1.default)({ ...requestConfig, method: 'delete' });
+}
+function createGetRequestStream(contentType) {
+    return async (accountId, options, destPath) => {
+        const { params, ...rest } = options;
+        const axiosConfig = (0, addQueryParams_1.addQueryParams)(rest, params);
+        // eslint-disable-next-line no-async-promise-executor
+        return new Promise(async (resolve, reject) => {
+            try {
+                const { headers, ...opts } = await withAuth(accountId, axiosConfig);
+                const res = await (0, axios_1.default)({
+                    method: 'get',
+                    ...opts,
+                    headers: {
+                        ...headers,
+                        accept: contentType,
+                    },
+                    responseType: 'stream',
+                });
+                if (res.status >= 200 && res.status < 300) {
+                    let filepath = destPath;
+                    if (fs_extra_1.default.existsSync(destPath)) {
+                        const stat = fs_extra_1.default.statSync(destPath);
+                        if (stat.isDirectory()) {
+                            const { parameters } = content_disposition_1.default.parse(res.headers['content-disposition'] || '');
+                            filepath = path_1.default.join(destPath, parameters.filename);
+                        }
+                    }
+                    try {
+                        fs_extra_1.default.ensureFileSync(filepath);
+                    }
+                    catch (err) {
+                        reject(err);
+                    }
+                    const writeStream = fs_extra_1.default.createWriteStream(filepath, {
+                        encoding: 'binary',
+                    });
+                    res.data.pipe(writeStream);
+                    writeStream.on('error', err => {
+                        reject(err);
+                    });
+                    writeStream.on('close', async () => {
+                        logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.createGetRequestStream.onWrite`, {
+                            filepath,
+                        }));
+                        resolve(res);
+                    });
+                }
+                else {
+                    reject(res);
+                }
+            }
+            catch (err) {
+                reject(err);
+            }
+        });
+    };
+}
+const getOctetStream = createGetRequestStream('application/octet-stream');
+exports.http = {
+    get: getRequest,
+    post: postRequest,
+    put: putRequest,
+    patch: patchRequest,
+    delete: deleteRequest,
+    getOctetStream,
+};

package/http/unauthed.d.ts

@@ -0,0 +1,15 @@
+import { AxiosPromise } from 'axios';
+import { HttpOptions } from '../types/Http';
+declare function getRequest<T>(options: HttpOptions): AxiosPromise<T>;
+declare function postRequest<T>(options: HttpOptions): AxiosPromise<T>;
+declare function putRequest<T>(options: HttpOptions): AxiosPromise<T>;
+declare function patchRequest<T>(options: HttpOptions): AxiosPromise<T>;
+declare function deleteRequest<T>(options: HttpOptions): AxiosPromise<T>;
+export declare const http: {
+    get: typeof getRequest;
+    post: typeof postRequest;
+    put: typeof putRequest;
+    patch: typeof patchRequest;
+    delete: typeof deleteRequest;
+};
+export {};

package/http/unauthed.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.http = void 0;
+const axios_1 = __importDefault(require("axios"));
+const getAxiosConfig_1 = require("./getAxiosConfig");
+const addQueryParams_1 = require("./addQueryParams");
+async function getRequest(options) {
+    const { params, ...rest } = options;
+    const optionsWithParams = (0, addQueryParams_1.addQueryParams)(rest, params);
+    const requestConfig = await (0, getAxiosConfig_1.getAxiosConfig)(optionsWithParams);
+    return (0, axios_1.default)(requestConfig);
+}
+async function postRequest(options) {
+    const requestConfig = await (0, getAxiosConfig_1.getAxiosConfig)(options);
+    return (0, axios_1.default)({ ...requestConfig, method: 'post' });
+}
+async function putRequest(options) {
+    const requestConfig = await (0, getAxiosConfig_1.getAxiosConfig)(options);
+    return (0, axios_1.default)({ ...requestConfig, method: 'put' });
+}
+async function patchRequest(options) {
+    const requestConfig = await (0, getAxiosConfig_1.getAxiosConfig)(options);
+    return (0, axios_1.default)({ ...requestConfig, method: 'patch' });
+}
+async function deleteRequest(options) {
+    const requestConfig = await (0, getAxiosConfig_1.getAxiosConfig)(options);
+    return (0, axios_1.default)({ ...requestConfig, method: 'delete' });
+}
+exports.http = {
+    get: getRequest,
+    post: postRequest,
+    put: putRequest,
+    patch: patchRequest,
+    delete: deleteRequest,
+};