@unito/integration-cli 0.57.1 → 0.58.0

package/dist/src/errors.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.handleError = exports.ConfigurationInvalid = exports.EntryDecryptionError = exports.DecryptionAuthenticationError = exports.AuthenticationFailed = exports.MissingApiKey = exports.FileSizeExceeded = exports.MissingAuth2AuthorizationError = exports.InvalidRequestContentTypeError = exports.FailedToRetrieveAccessTokenError = exports.NoRefreshTokenError = exports.ConfigurationMalformed = exports.NoConfigurationFileError = exports.NoIntegrationFoundError = void 0;
+exports.handleError = exports.ConfigurationInvalid = exports.EntryDecryptionError = exports.IntegrationAlreadyExistsError = exports.CredentialAccessDenied = exports.CredentialAuthenticationError = exports.UnsupportedContentTypeError = exports.DecryptionAuthenticationError = exports.AuthenticationFailed = exports.MissingApiKey = exports.FileSizeExceeded = exports.MissingAuth2AuthorizationError = exports.InvalidRequestContentTypeError = exports.FailedToRetrieveAccessTokenError = exports.NoRefreshTokenError = exports.ConfigurationMalformed = exports.NoConfigurationFileError = exports.NoIntegrationFoundError = void 0;
 const tslib_1 = require("tslib");
 const core_1 = require("@oclif/core");
 const chalk_1 = tslib_1.__importDefault(require("chalk"));
@@ -41,6 +41,18 @@ exports.AuthenticationFailed = AuthenticationFailed;
 class DecryptionAuthenticationError extends Error {
 }
 exports.DecryptionAuthenticationError = DecryptionAuthenticationError;
+class UnsupportedContentTypeError extends Error {
+}
+exports.UnsupportedContentTypeError = UnsupportedContentTypeError;
+class CredentialAuthenticationError extends Error {
+}
+exports.CredentialAuthenticationError = CredentialAuthenticationError;
+class CredentialAccessDenied extends Error {
+}
+exports.CredentialAccessDenied = CredentialAccessDenied;
+class IntegrationAlreadyExistsError extends Error {
+}
+exports.IntegrationAlreadyExistsError = IntegrationAlreadyExistsError;
 class EntryDecryptionError extends Error {
     key;
     value;
@@ -68,45 +80,37 @@ function handleError(command, error) {
     if (core_1.ux.action.running) {
         core_1.ux.action.stop(chalk_1.default.redBright('failed'));
     }
-    let handled = false;
+    let unhandled = false;
     if (error instanceof NoIntegrationFoundError) {
         command.logToStderr(chalk_1.default.redBright('Your directory does not seem to contain an integration :('));
         command.logToStderr(`Make sure you are in the right directory and that you have a ${chalk_1.default.yellowBright(configuration_1.DEFAULT_CONFIGURATION_NAME)} file.`);
-        handled = true;
     }
     else if (error instanceof NoConfigurationFileError) {
         command.logToStderr(chalk_1.default.redBright('This command requires a configuration file for your integration :('));
         command.logToStderr(`This file should be located at ${chalk_1.default.yellowBright(path_1.default.relative(process.cwd(), (0, configuration_1.getConfigurationPath)()))}.`);
-        handled = true;
     }
     else if (error instanceof ConfigurationMalformed) {
         command.logToStderr(chalk_1.default.redBright(`Your ${chalk_1.default.yellowBright(configuration_1.DEFAULT_CONFIGURATION_NAME)} was found but its not a valid JSON file!`));
-        handled = true;
     }
     else if (error instanceof ConfigurationInvalid) {
         command.logToStderr(chalk_1.default.redBright(`Your ${chalk_1.default.yellowBright(configuration_1.DEFAULT_CONFIGURATION_NAME)} is invalid!`));
         command.logToStderr();
         command.logToStderr(error.prettyDetails);
-        handled = true;
     }
     else if (error instanceof NoRefreshTokenError) {
         command.logToStderr(chalk_1.default.redBright('No refresh token found in your configuration file'));
-        handled = true;
     }
     else if (error instanceof FailedToRetrieveAccessTokenError) {
         command.logToStderr(chalk_1.default.redBright('Failed to retrieve access token'));
         command.logToStderr();
         command.logToStderr(error.message);
-        handled = true;
     }
     else if (error instanceof InvalidRequestContentTypeError) {
         command.logToStderr(chalk_1.default.redBright('Invalid request content type'));
-        handled = true;
         command.logToStderr();
         command.logToStderr(error.message);
     }
     else if (error instanceof integrationsPlatform_1.HttpError) {
-        handled = true;
         command.logToStderr();
         command.logToStderr((0, json_colorizer_1.default)(JSON.stringify(error.data, null, 2)));
     }
@@ -114,13 +118,11 @@ function handleError(command, error) {
         command.logToStderr();
         command.logToStderr(chalk_1.default.redBright('Your API key is not set!'));
         command.logToStderr(`Make sure to run the ${chalk_1.default.yellowBright('login')} command first.`);
-        handled = true;
     }
     else if (error instanceof AuthenticationFailed) {
         command.logToStderr();
         command.logToStderr(chalk_1.default.redBright('This command requires that you are logged to Unito!'));
         command.logToStderr(`Make sure to run the ${chalk_1.default.yellowBright('login')} command first.`);
-        handled = true;
     }
     else if (error instanceof DecryptionAuthenticationError) {
         command.logToStderr();
@@ -128,7 +130,6 @@ function handleError(command, error) {
         command.logToStderr('Your configuration contains secrets (i.e. in top-level secrets, in test accounts, etc.).');
         command.logToStderr('To decrypt those secrets locally, you must authenticate to Unito.');
         command.logToStderr(`Make sure to run the ${chalk_1.default.yellowBright('login')} command first.`);
-        handled = true;
     }
     else if (error instanceof EntryDecryptionError) {
         command.logToStderr();
@@ -140,15 +141,31 @@ function handleError(command, error) {
         command.logToStderr(`1. The integration was deployed once with the ${chalk_1.default.yellowBright('publish')} command.`);
         command.logToStderr('2. You have access to the integration.');
         command.logToStderr(`3. The secret was encrypted for the ${chalk_1.default.yellowBright(error.environment)} environment.`);
-        handled = true;
     }
     else if (error instanceof MissingAuth2AuthorizationError) {
         command.logToStderr();
         command.logToStderr(chalk_1.default.redBright(`No Oauth2 authorization found in your configuration file`));
-        // TODO: Update link once the documentation is made available publicly
-        command.logToStderr('See https://staging-dev.unito.io/docs/integrations/configuration/authorizations#oauth-2 for more information on how to configure Oauth2');
-        handled = true;
+        command.logToStderr('See https://dev.unito.io/docs/connectors/configuration/authorizations#oauth-2 for more information on how to configure Oauth2');
+    }
+    else if (error instanceof CredentialAuthenticationError) {
+        command.logToStderr();
+        command.logToStderr(chalk_1.default.redBright('The credential cannot be obtained!'));
+        command.logToStderr('To obtain information on the credential, you must authenticate to Unito.');
+        command.logToStderr(`Make sure to run the ${chalk_1.default.yellowBright('login')} command first.`);
+    }
+    else if (error instanceof CredentialAccessDenied) {
+        command.logToStderr();
+        command.logToStderr(chalk_1.default.redBright('The credential cannot be obtained!'));
+        command.logToStderr("You don't have access to this credential or the credential doesn't exist.");
+    }
+    else if (error instanceof IntegrationAlreadyExistsError) {
+        command.logToStderr();
+        command.logToStderr(chalk_1.default.redBright(`The integration already exists in this folder.`));
+        command.logToStderr(`Make sure to provide a unique name for your integration.`);
+    }
+    else {
+        unhandled = true;
     }
-    return handled;
+    return !unhandled;
 }
 exports.handleError = handleError;

package/dist/src/resources/configuration.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.writeTestAccount = exports.writeConfiguration = exports.getConfiguration = exports.getConfigurationPath = exports.ENCRYPTION_PREFIX = exports.DEFAULT_CONFIGURATION_NAME = exports.CredentialScope = exports.CrawlMode = void 0;
 const tslib_1 = require("tslib");
-const core_1 = require("@oclif/core");
 const fs = tslib_1.__importStar(require("fs"));
 const ajv_1 = tslib_1.__importDefault(require("ajv"));
 const ajv_formats_1 = tslib_1.__importDefault(require("ajv-formats"));
@@ -48,7 +47,6 @@ async function getConfiguration(environment, customConfigPath) {
     const configurationPath = customConfigPath
         ? `${process.cwd()}${customConfigPath.startsWith('/') ? customConfigPath : `/${customConfigPath}`}`
         : getConfigurationPath(environment);
-    core_1.ux.log(`Loading ${configurationPath} configuration file`);
     try {
         fileContent = await fs.promises.readFile(configurationPath, 'utf-8');
     }

package/dist/src/resources/credentials.d.ts

@@ -0,0 +1,3 @@
+import * as GlobalConfiguration from './globalConfiguration';
+import { Credential } from '../services/integrationsPlatform';
+export declare function fetchCredential(environment: GlobalConfiguration.Environment, configDir: string, credentialId: number): Promise<Credential>;

package/dist/src/resources/credentials.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchCredential = void 0;
+const tslib_1 = require("tslib");
+const errors_1 = require("../errors");
+const GlobalConfiguration = tslib_1.__importStar(require("./globalConfiguration"));
+const integrationsPlatform_1 = require("./integrationsPlatform");
+const integrationsPlatform_2 = require("../services/integrationsPlatform");
+async function fetchCredential(environment, configDir, credentialId) {
+    const globalConfiguration = await GlobalConfiguration.read(configDir);
+    try {
+        await (0, integrationsPlatform_1.validateAuthenticated)(globalConfiguration, environment);
+    }
+    catch {
+        throw new errors_1.CredentialAuthenticationError();
+    }
+    let credential;
+    try {
+        credential = await (0, integrationsPlatform_2.getCredential)(credentialId);
+    }
+    catch {
+        throw new errors_1.CredentialAccessDenied();
+    }
+    return credential;
+}
+exports.fetchCredential = fetchCredential;

package/dist/src/resources/integrations.d.ts

@@ -1,2 +1,3 @@
 export declare function validateIsIntegrationDirectory(): void;
 export declare function isIntegrationDirectory(): boolean;
+export declare function copyBoilerplate(integrationName: string, destinationPath: string): Promise<string>;

package/dist/src/resources/integrations.js

@@ -1,13 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isIntegrationDirectory = exports.validateIsIntegrationDirectory = void 0;
+exports.copyBoilerplate = exports.isIntegrationDirectory = exports.validateIsIntegrationDirectory = void 0;
 const tslib_1 = require("tslib");
+const path_1 = tslib_1.__importDefault(require("path"));
 const fs_1 = tslib_1.__importDefault(require("fs"));
 const errors_1 = require("../errors");
+const errors_2 = require("../errors");
 const configuration_1 = require("./configuration");
 function validateIsIntegrationDirectory() {
     if (!isIntegrationDirectory()) {
-        throw new errors_1.NoIntegrationFoundError();
+        throw new errors_2.NoIntegrationFoundError();
     }
 }
 exports.validateIsIntegrationDirectory = validateIsIntegrationDirectory;
@@ -15,3 +17,36 @@ function isIntegrationDirectory() {
     return fs_1.default.existsSync((0, configuration_1.getConfigurationPath)());
 }
 exports.isIntegrationDirectory = isIntegrationDirectory;
+async function copyBoilerplate(integrationName, destinationPath) {
+    const sourcePath = path_1.default.join(__dirname, `../../boilerplate`);
+    const targetPath = `${destinationPath}/${integrationName.toLowerCase().replace(/ /g, '_')}`;
+    if (fs_1.default.existsSync(targetPath)) {
+        throw new errors_1.IntegrationAlreadyExistsError();
+    }
+    await fs_1.default.promises.mkdir(targetPath, { recursive: true });
+    await copyFilesAndFolders(sourcePath, targetPath, ['node_modules', 'dist']);
+    // The .npmrc file is created here because
+    // it will be excluded during the CLI package's publishing process by npm.
+    const npmrcContent = ['engine-strict=true', 'strict-ssl=true'].join('\n');
+    await fs_1.default.promises.writeFile(path_1.default.join(targetPath, '.npmrc'), npmrcContent);
+    return targetPath;
+}
+exports.copyBoilerplate = copyBoilerplate;
+async function copyFilesAndFolders(source, destination, excludedFolders) {
+    const files = await fs_1.default.promises.readdir(source);
+    for (const file of files) {
+        if (excludedFolders.includes(file)) {
+            continue;
+        }
+        const sourcePath = path_1.default.join(source, file);
+        const targetPath = path_1.default.join(destination, file);
+        const stats = await fs_1.default.promises.stat(sourcePath);
+        if (stats.isFile()) {
+            await fs_1.default.promises.copyFile(sourcePath, targetPath);
+        }
+        else if (stats.isDirectory()) {
+            await fs_1.default.promises.mkdir(targetPath);
+            await copyFilesAndFolders(sourcePath, targetPath, excludedFolders);
+        }
+    }
+}

package/dist/src/resources/oauth2Helper.d.ts

@@ -0,0 +1,4 @@
+import { Oauth2Response, Oauth2Payload } from '../services/oauth2Helper';
+import { Environment } from './globalConfiguration';
+export declare function performOAuth2Flow(applicationCredentials: Oauth2Payload, environment?: Environment): Promise<Oauth2Response>;
+export declare function updateToken(applicationCredentials: Oauth2Payload, refreshToken: string): Promise<Oauth2Response>;

package/dist/src/resources/oauth2Helper.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateToken = exports.performOAuth2Flow = void 0;
+const tslib_1 = require("tslib");
+const oauth2Helper_1 = tslib_1.__importDefault(require("../services/oauth2Helper"));
+const errors_1 = require("../errors");
+const globalConfiguration_1 = require("./globalConfiguration");
+async function performOAuth2Flow(applicationCredentials, environment = globalConfiguration_1.Environment.Production) {
+    const oauthHelper = new oauth2Helper_1.default(applicationCredentials, environment);
+    const serverUrl = await oauthHelper.startServer();
+    const healthCheck = await fetch(`${serverUrl}/health`);
+    if (healthCheck.status !== 200) {
+        throw new Error('OAuthServer did not start');
+    }
+    await oauthHelper.authorize();
+    const oauth2Response = await oauthHelper.callbackIsDone();
+    await oauthHelper.stopServer();
+    if (!oauth2Response.accessToken) {
+        throw new errors_1.FailedToRetrieveAccessTokenError('Access token was not returned');
+    }
+    return oauth2Response;
+}
+exports.performOAuth2Flow = performOAuth2Flow;
+/* istanbul ignore next */
+// No point to test this function as it is just a wrapper around OAuth2Helper
+async function updateToken(applicationCredentials, refreshToken) {
+    const oauthHelper = new oauth2Helper_1.default(applicationCredentials);
+    return oauthHelper.updateToken(refreshToken);
+}
+exports.updateToken = updateToken;

package/dist/src/services/integrationsPlatform.d.ts

@@ -38,3 +38,4 @@ export declare function getIntegrationEvents(integrationId: number, options?: {
     limit?: number;
 }): Promise<IntegrationEvent[]>;
 export declare function updateIntegration(integrationId: number, configuration: Configuration): Promise<Integration>;
+export declare function getCredential(credentialId: number): Promise<Credential>;

package/dist/src/services/integrationsPlatform.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.updateIntegration = exports.getIntegrationEvents = exports.inviteUserToIntegration = exports.createIntegration = exports.publishIntegration = exports.getIntegrations = exports.getIntegrationByName = exports.getIntegration = exports.reencryptData = exports.decryptData = exports.encryptData = exports.getProfile = exports.setApiKey = exports.getApiKey = exports.setEnvironment = exports.Servers = exports.HttpError = void 0;
+exports.getCredential = exports.updateIntegration = exports.getIntegrationEvents = exports.inviteUserToIntegration = exports.createIntegration = exports.publishIntegration = exports.getIntegrations = exports.getIntegrationByName = exports.getIntegration = exports.reencryptData = exports.decryptData = exports.encryptData = exports.getProfile = exports.setApiKey = exports.getApiKey = exports.setEnvironment = exports.Servers = exports.HttpError = void 0;
 const tslib_1 = require("tslib");
 const fs = tslib_1.__importStar(require("fs"));
 const integrations_platform_client_1 = tslib_1.__importDefault(require("@unito/integrations-platform-client"));
@@ -153,3 +153,7 @@ async function updateIntegration(integrationId, configuration) {
     });
 }
 exports.updateIntegration = updateIntegration;
+async function getCredential(credentialId) {
+    return integrations_platform_client_1.default.getCredentialById(credentialId);
+}
+exports.getCredential = getCredential;

package/dist/src/services/oauth2Helper.d.ts

@@ -1,3 +1,78 @@
-import { Oauth2Response, Oauth2Payload } from '../oauth2Helper/types';
-export declare function performOAuth2Flow(applicationCredentials: Oauth2Payload): Promise<Oauth2Response>;
-export declare function updateToken(applicationCredentials: Oauth2Payload): Promise<Oauth2Response>;
+import * as openUrl from 'openurl';
+import { Oauth2 } from '../configurationTypes';
+import { Environment } from '../resources/globalConfiguration';
+export declare const open: typeof openUrl;
+export declare const HTML_ERROR_MSG = "<!doctype html><head><title>Unito</title></head><body style=\"text-align:center\"> An unknown error occured </body>";
+export declare const HTML_SUCCESS_MSG = "<!doctype html><head><title>Unito</title></head><body style=\"text-align:center\"> Redirected to the CLI successfully </body>";
+export interface Oauth2Credentials {
+    clientId: string;
+    clientSecret: string;
+}
+export interface AuthorizePayload extends Oauth2Credentials {
+    providerAuthorizationUrl: string;
+    scopes?: string;
+    providerAccessTokenUrl: string;
+}
+export interface CallbackPayload {
+    code: string;
+}
+export interface Oauth2Response {
+    accessToken: string;
+    refreshToken?: string;
+}
+export interface TokenPayload extends Oauth2Credentials {
+    providerTokenUrl: string;
+    code: string;
+}
+export type Oauth2Payload = Oauth2;
+declare class OAuth2Helper {
+    private environment;
+    private server;
+    private clientId;
+    private clientSecret;
+    private providerAuthorizationUrl;
+    private tokenUrl;
+    private scopes;
+    private grantType;
+    private requestContentType;
+    private oauth2Response;
+    private serverUrl;
+    private tokenRequestParameters;
+    private refreshRequestParameters;
+    /**
+     * Constructs an instance of OAuthHelper.
+     * @param clientId The client ID for your OAuth application.
+     * @param clientSecret The client secret for your OAuth application.
+     * @param authorizationUrl The URL for the authorization endpoint of the provider.
+     * @param scopes The scopes required for the OAuth authorization.
+     * @param providerTokenUrl The URL for the token endpoint of the provider.
+     */
+    constructor(authorizationInfo: Oauth2Payload, environment?: Environment);
+    /**
+     * Initiate the authorization flow and redirects the user to the provider's authorization page.
+     */
+    authorize(): Promise<void>;
+    /**
+     * Handles the callback request from the provider and stores the authorization code.
+     * @param req The express Request object.
+     * @param res The express Response object.
+     */
+    private handleCallback;
+    /**
+     * Waits for the authorization code to be set.
+     * @returns A promise that resolves when the code is set.
+     */
+    callbackIsDone(): Promise<Oauth2Response>;
+    private encodeBody;
+    updateToken(refreshToken: string): Promise<Oauth2Response>;
+    /**
+     * Starts the Express server for handling OAuth callbacks.
+     * @returns The URL of the server.
+     */
+    startServer(): Promise<string>;
+    /**
+     * Stops the Express server.
+     */
+    stopServer(): Promise<void>;
+}
+export default OAuth2Helper;

package/dist/src/services/oauth2Helper.js

@@ -1,34 +1,234 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.updateToken = exports.performOAuth2Flow = void 0;
+exports.HTML_SUCCESS_MSG = exports.HTML_ERROR_MSG = exports.open = void 0;
 const tslib_1 = require("tslib");
-const oauth2Helper_1 = tslib_1.__importDefault(require("../oauth2Helper/oauth2Helper"));
+const express_1 = tslib_1.__importDefault(require("express"));
+const cors_1 = tslib_1.__importDefault(require("cors"));
+const openUrl = tslib_1.__importStar(require("openurl"));
+const ngrok_1 = tslib_1.__importDefault(require("ngrok"));
+const IntegrationsPlatformClient = tslib_1.__importStar(require("./integrationsPlatform"));
+const configurationTypes_1 = require("../configurationTypes");
 const errors_1 = require("../errors");
-async function performOAuth2Flow(applicationCredentials) {
-    const oauthHelper = new oauth2Helper_1.default(applicationCredentials);
-    const serverUrl = oauthHelper.startServer();
-    const healthCheck = await fetch(`${serverUrl}/health`);
-    if (healthCheck.status !== 200) {
-        throw new Error('OAuthServer did not start');
-    }
-    await fetch(`${serverUrl}/credentials/new/oauth2/authorize`);
-    await oauthHelper.callbackIsDone();
-    const response = await fetch(`${serverUrl}/credentials/new/oauth2/token`);
-    if (response.status !== 200) {
-        throw new errors_1.FailedToRetrieveAccessTokenError(await response.text());
-    }
-    const credentials = await response.json();
-    oauthHelper.stopServer();
-    if (!credentials.accessToken) {
-        throw new errors_1.FailedToRetrieveAccessTokenError('Access token was not returned');
-    }
-    return credentials;
-}
-exports.performOAuth2Flow = performOAuth2Flow;
-/* istanbul ignore next */
-// No point to test this function as it is just a wrapper around OAuth2Helper
-async function updateToken(applicationCredentials) {
-    const oauthHelper = new oauth2Helper_1.default(applicationCredentials);
-    return oauthHelper.updateToken();
+const globalConfiguration_1 = require("../resources/globalConfiguration");
+// It allows to stub openUrl library in the test
+exports.open = openUrl;
+exports.HTML_ERROR_MSG = `<!doctype html><head><title>Unito</title></head><body style="text-align:center"> An unknown error occured </body>`;
+exports.HTML_SUCCESS_MSG = `<!doctype html><head><title>Unito</title></head><body style="text-align:center"> Redirected to the CLI successfully </body>`;
+class OAuth2Helper {
+    environment;
+    server = null;
+    clientId;
+    clientSecret;
+    providerAuthorizationUrl;
+    tokenUrl;
+    scopes;
+    grantType;
+    requestContentType;
+    oauth2Response;
+    serverUrl = '';
+    tokenRequestParameters;
+    refreshRequestParameters;
+    /**
+     * Constructs an instance of OAuthHelper.
+     * @param clientId The client ID for your OAuth application.
+     * @param clientSecret The client secret for your OAuth application.
+     * @param authorizationUrl The URL for the authorization endpoint of the provider.
+     * @param scopes The scopes required for the OAuth authorization.
+     * @param providerTokenUrl The URL for the token endpoint of the provider.
+     */
+    constructor(authorizationInfo, environment = globalConfiguration_1.Environment.Production) {
+        const { clientId, clientSecret, authorizationUrl, scopes, tokenUrl, grantType, requestContentType, refreshRequestParameters, tokenRequestParameters, } = authorizationInfo;
+        this.startServer = this.startServer.bind(this);
+        this.stopServer = this.stopServer.bind(this);
+        this.handleCallback = this.handleCallback.bind(this);
+        this.clientId = clientId;
+        this.clientSecret = clientSecret;
+        this.providerAuthorizationUrl = authorizationUrl;
+        this.scopes = scopes.map(scope => scope.name);
+        this.tokenUrl = tokenUrl;
+        this.grantType = grantType ?? configurationTypes_1.GrantType.AUTHORIZATION_CODE;
+        this.requestContentType = requestContentType ?? configurationTypes_1.RequestContentType.URL_ENCODED;
+        this.tokenRequestParameters = tokenRequestParameters;
+        this.refreshRequestParameters = refreshRequestParameters;
+        this.environment = environment;
+        if (!Object.values(configurationTypes_1.RequestContentType).includes(this.requestContentType)) {
+            throw new errors_1.UnsupportedContentTypeError(`Request content type not supported: ${this.requestContentType}`);
+        }
+    }
+    /**
+     * Initiate the authorization flow and redirects the user to the provider's authorization page.
+     */
+    async authorize() {
+        if (!this.providerAuthorizationUrl) {
+            throw new errors_1.InvalidRequestContentTypeError('authorizationUrl must be defined in .unito.json');
+        }
+        const authUrl = new URL(this.providerAuthorizationUrl);
+        const params = new URLSearchParams(authUrl.search);
+        if (this.clientId) {
+            params.set('client_id', this.clientId);
+        }
+        params.set('redirect_uri', `${IntegrationsPlatformClient.Servers[this.environment]}/credentials/new/oauth2/callback-cli`);
+        const state = Buffer.from(JSON.stringify({
+            cliCallbackUrl: `${this.serverUrl}/oauth2/callback`,
+        })).toString('base64');
+        params.set('state', state);
+        if (this.scopes) {
+            params.set('scope', this.scopes.join(' '));
+        }
+        params.set('response_type', 'code');
+        authUrl.search = params.toString();
+        exports.open.open(authUrl.toString());
+    }
+    /**
+     * Handles the callback request from the provider and stores the authorization code.
+     * @param req The express Request object.
+     * @param res The express Response object.
+     */
+    async handleCallback(req, res) {
+        // Authorization Response: https://www.rfc-editor.org/rfc/rfc6749#section-4.1.2
+        // const state = req.state as string;
+        // Error response: https://www.rfc-editor.org/rfc/rfc6749#section-4.1.2.1
+        const error = req.query.error;
+        if (error) {
+            res.setHeader('Content-Type', 'text/html').send(exports.HTML_ERROR_MSG);
+            return;
+        }
+        const code = req.query.code;
+        const bodyData = {
+            code,
+            grant_type: this.grantType,
+            redirect_uri: `${IntegrationsPlatformClient.Servers[this.environment]}/credentials/new/oauth2/callback-cli`,
+        };
+        if (this.clientId) {
+            bodyData.client_id = this.clientId;
+        }
+        if (this.clientSecret) {
+            bodyData.client_secret = this.clientSecret;
+        }
+        const fetchOptions = {
+            headers: {
+                'Content-type': this.requestContentType,
+                ...(this.tokenRequestParameters?.header ?? {}),
+            },
+            body: this.encodeBody(bodyData, this.requestContentType),
+            method: 'POST',
+        };
+        try {
+            const fetchResult = await fetch(this.tokenUrl, fetchOptions);
+            if (fetchResult.status !== 200) {
+                res.setHeader('Content-Type', 'text/html');
+                res.send(exports.HTML_ERROR_MSG);
+            }
+            const response = await fetchResult.json();
+            this.oauth2Response = {
+                accessToken: response.access_token,
+                refreshToken: response.refresh_token,
+            };
+            res.setHeader('Content-Type', 'text/html');
+            res.send(exports.HTML_SUCCESS_MSG);
+        }
+        catch (error) {
+            res.setHeader('Content-Type', 'text/html');
+            res.send(exports.HTML_ERROR_MSG);
+        }
+    }
+    /**
+     * Waits for the authorization code to be set.
+     * @returns A promise that resolves when the code is set.
+     */
+    /* istanbul ignore next */
+    async callbackIsDone() {
+        if (this.oauth2Response) {
+            return this.oauth2Response;
+        }
+        else {
+            return new Promise(resolve => {
+                const interval = setInterval(() => {
+                    if (this.oauth2Response) {
+                        clearInterval(interval);
+                        resolve(this.oauth2Response);
+                    }
+                }, 100);
+            });
+        }
+    }
+    encodeBody(bodyData, contentType) {
+        switch (contentType) {
+            case configurationTypes_1.RequestContentType.URL_ENCODED:
+                return new URLSearchParams(bodyData).toString();
+            case configurationTypes_1.RequestContentType.JSON:
+                return JSON.stringify(bodyData);
+        }
+    }
+    async updateToken(refreshToken) {
+        if (!Object.values(configurationTypes_1.RequestContentType).includes(this.requestContentType)) {
+            throw new errors_1.InvalidRequestContentTypeError(`Request content type not supported: ${this.requestContentType}`);
+        }
+        const bodyData = {
+            grant_type: 'refresh_token',
+            refresh_token: refreshToken,
+        };
+        if (this.clientId) {
+            bodyData.client_id = this.clientId;
+        }
+        if (this.clientSecret) {
+            bodyData.client_secret = this.clientSecret;
+        }
+        const fetchOptions = {
+            headers: {
+                'Content-type': this.requestContentType,
+                ...(this.refreshRequestParameters?.header ?? {}),
+            },
+            body: this.encodeBody(bodyData, this.requestContentType),
+            method: 'POST',
+        };
+        try {
+            const fetchResult = await fetch(this.tokenUrl, fetchOptions);
+            if (fetchResult.status !== 200) {
+                throw new errors_1.FailedToRetrieveAccessTokenError(await fetchResult.text());
+            }
+            const response = await fetchResult.json();
+            const credentialsInfo = {
+                accessToken: response.access_token,
+                refreshToken: response.refresh_token,
+            };
+            return credentialsInfo;
+        }
+        catch (error) {
+            throw new errors_1.FailedToRetrieveAccessTokenError(JSON.stringify(error));
+        }
+    }
+    /**
+     * Starts the Express server for handling OAuth callbacks.
+     * @returns The URL of the server.
+     */
+    /* istanbul ignore next */
+    async startServer() {
+        const app = (0, express_1.default)();
+        const PORT = process.env.OAUTH2_PORT ?? 9002;
+        this.serverUrl = await ngrok_1.default.connect(Number(PORT));
+        app.use((0, cors_1.default)({ credentials: true, origin: true }));
+        app.use(express_1.default.json());
+        app.get('/health', (_req, res) => {
+            res.send('pong');
+        });
+        app.get('/oauth2/callback', this.handleCallback);
+        this.server = app.listen(PORT, () => {
+            console.log(`Listening at port ${PORT}`);
+        });
+        return this.serverUrl;
+    }
+    /**
+     * Stops the Express server.
+     */
+    /* istanbul ignore next */
+    async stopServer() {
+        if (this.server) {
+            await ngrok_1.default.kill();
+            this.server.close(() => {
+                console.log('Server has stopped');
+            });
+        }
+    }
 }
-exports.updateToken = updateToken;
+exports.default = OAuth2Helper;