@unito/integration-cli 0.55.1

package/dist/src/oauth2Helper/oauth2Helper.js

@@ -0,0 +1,235 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.open = void 0;
+const tslib_1 = require("tslib");
+const express_1 = tslib_1.__importDefault(require("express"));
+const cors_1 = tslib_1.__importDefault(require("cors"));
+const openUrl = tslib_1.__importStar(require("openurl"));
+const configurationTypes_1 = require("../configurationTypes");
+const errors_1 = require("../errors");
+// It allows to stub openUrl library in the test
+exports.open = openUrl;
+class OAuth2Helper {
+    server = null;
+    clientId;
+    clientSecret;
+    providerAuthorizationUrl;
+    tokenUrl;
+    scopes;
+    grantType;
+    requestContentType;
+    responseContentType;
+    refreshToken;
+    code = '';
+    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) {
+        const { clientId, clientSecret, authorizationUrl, scopes, tokenUrl, grantType, requestContentType, responseContentType, refreshToken, refreshRequestParameters, tokenRequestParameters, } = authorizationInfo;
+        this.startServer = this.startServer.bind(this);
+        this.stopServer = this.stopServer.bind(this);
+        this.handleAuthorize = this.handleAuthorize.bind(this);
+        this.handleCallback = this.handleCallback.bind(this);
+        this.handleToken = this.handleToken.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.responseContentType = responseContentType ?? configurationTypes_1.RequestContentType.JSON;
+        this.refreshToken = refreshToken;
+        this.tokenRequestParameters = tokenRequestParameters;
+        this.refreshRequestParameters = refreshRequestParameters;
+    }
+    /**
+     * Handles the authorization request and redirects the user to the provider's authorization page.
+     * @param req The express Request object.
+     * @param res The express Response object.
+     */
+    async handleAuthorize(_req, res) {
+        if (!this.providerAuthorizationUrl) {
+            res.status(422).send({ message: 'providerAuthorizationUrl must be defined in .unito.json' });
+            return;
+        }
+        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', `${this.serverUrl}/credentials/new/oauth2/callback`);
+        if (this.scopes) {
+            params.set('scope', this.scopes.join(' '));
+        }
+        params.set('response_type', 'code');
+        authUrl.search = params.toString();
+        exports.open.open(authUrl.toString());
+        res.json();
+    }
+    /**
+     * 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) {
+        const { code } = req.query;
+        this.code = code;
+        res.json();
+    }
+    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);
+        }
+    }
+    /**
+     * Handles the token request to exchange the authorization code for an access token.
+     * @param req The express Request object.
+     * @param res The express Response object.
+     */
+    async handleToken(_req, res) {
+        if (!Object.values(configurationTypes_1.RequestContentType).includes(this.requestContentType)) {
+            res.status(400).json({ error: `Request content type not supported: ${this.requestContentType}` });
+        }
+        const bodyData = {
+            code: this.code,
+            grant_type: this.grantType,
+            redirect_uri: `${this.serverUrl}/credentials/new/oauth2/callback`,
+        };
+        if (this.clientId) {
+            bodyData.client_id = this.clientId;
+        }
+        if (this.clientSecret) {
+            bodyData.client_secret = this.clientSecret;
+        }
+        const body = this.encodeBody(bodyData, this.requestContentType);
+        const fetchOptions = {
+            headers: {
+                'Content-type': this.requestContentType,
+                ...(this.tokenRequestParameters?.header ?? {}),
+            },
+            body,
+            method: 'POST',
+        };
+        try {
+            const fetchResult = await fetch(this.tokenUrl, fetchOptions);
+            if (fetchResult.status !== 200) {
+                res.status(500).json({ error: `Error fetching token: ${await fetchResult.text()}` });
+            }
+            const response = await fetchResult.json();
+            const credentialsInfo = {
+                accessToken: response.access_token,
+                refreshToken: response.refresh_token,
+            };
+            res.json(credentialsInfo);
+        }
+        catch (error) {
+            res.status(500).json({ error: 'Failed to retrieve access token' });
+        }
+    }
+    async updateToken() {
+        if (!this.refreshToken) {
+            throw new errors_1.NoRefreshTokenError();
+        }
+        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: this.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 */
+    startServer() {
+        const app = (0, express_1.default)();
+        const PORT = process.env.OAUTH2_PORT ?? 9002;
+        app.use((0, cors_1.default)({ credentials: true, origin: true }));
+        app.get('/health', (req, res) => {
+            res.send('pong');
+        });
+        app.get('/credentials/new/oauth2/authorize', this.handleAuthorize);
+        app.get('/credentials/new/oauth2/callback', this.handleCallback);
+        app.get('/credentials/new/oauth2/token', this.handleToken);
+        this.server = app.listen(PORT, () => {
+            console.log(`Listening at port ${PORT}`);
+        });
+        this.serverUrl = `http://localhost:${PORT}`;
+        return this.serverUrl;
+    }
+    /**
+     * Stops the Express server.
+     */
+    /* istanbul ignore next */
+    stopServer() {
+        if (this.server) {
+            this.server.close(() => {
+                console.log('Server has stopped');
+            });
+        }
+    }
+    /**
+     * 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.code) {
+            return true;
+        }
+        else {
+            return new Promise(resolve => {
+                const interval = setInterval(() => {
+                    if (this.code) {
+                        clearInterval(interval);
+                        resolve(true);
+                    }
+                }, 100);
+            });
+        }
+    }
+}
+exports.default = OAuth2Helper;

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

@@ -0,0 +1,22 @@
+import { Oauth2 } from '../configurationTypes';
+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 & Omit<Oauth2Response, 'accessToken'>;

package/dist/src/oauth2Helper/types.js

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

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

@@ -0,0 +1,30 @@
+import { Configuration } from '../configurationTypes';
+import { Environment } from './globalConfiguration';
+export declare enum CrawlMode {
+    FULL = "full",
+    SAMPLE = "sample",
+    SINGLE = "single"
+}
+export declare enum CredentialScope {
+    DEVELOPMENT = "development",
+    COMPLIANCE = "compliance"
+}
+export declare const DEFAULT_CONFIGURATION_NAME: string;
+export declare const ENCRYPTION_PREFIX = "unito-secret-v1://";
+/**
+ * Check for environment specific configuration, otherwise uses the default one.
+ *
+ * Production environment always uses the default configuration.
+ * @param environment targeted environment
+ * @returns path to the environment configuration file
+ */
+export declare function getConfigurationPath(environment?: Environment): string;
+export declare function getConfiguration(environment: Environment, customConfigPath?: string): Promise<Configuration>;
+/**
+ * Write the configuration to the default configuration file.
+ */
+export declare function writeConfiguration(configuration: Configuration): Promise<void>;
+export declare function writeTestAccount(configuration: Configuration, account: {
+    accessToken: string;
+    refreshToken?: string;
+}, accountName: string): Promise<void>;

package/dist/src/resources/configuration.js

@@ -0,0 +1,191 @@
+"use strict";
+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"));
+const better_ajv_errors_1 = tslib_1.__importDefault(require("better-ajv-errors"));
+const configurationTypes_1 = require("../configurationTypes");
+const errors_1 = require("../errors");
+const integrations_1 = require("./integrations");
+const globalConfiguration_1 = require("./globalConfiguration");
+var CrawlMode;
+(function (CrawlMode) {
+    CrawlMode["FULL"] = "full";
+    CrawlMode["SAMPLE"] = "sample";
+    CrawlMode["SINGLE"] = "single";
+})(CrawlMode || (exports.CrawlMode = CrawlMode = {}));
+var CredentialScope;
+(function (CredentialScope) {
+    CredentialScope["DEVELOPMENT"] = "development";
+    CredentialScope["COMPLIANCE"] = "compliance";
+})(CredentialScope || (exports.CredentialScope = CredentialScope = {}));
+exports.DEFAULT_CONFIGURATION_NAME = '.unito.json';
+exports.ENCRYPTION_PREFIX = 'unito-secret-v1://';
+/**
+ * Check for environment specific configuration, otherwise uses the default one.
+ *
+ * Production environment always uses the default configuration.
+ * @param environment targeted environment
+ * @returns path to the environment configuration file
+ */
+function getConfigurationPath(environment = globalConfiguration_1.Environment.Production) {
+    const environmentBasedPath = `${process.cwd()}/.unito.${environment}.json`;
+    if (environment !== globalConfiguration_1.Environment.Production && fs.existsSync(environmentBasedPath)) {
+        return environmentBasedPath;
+    }
+    else {
+        return `${process.cwd()}/${exports.DEFAULT_CONFIGURATION_NAME}`;
+    }
+}
+exports.getConfigurationPath = getConfigurationPath;
+async function getConfiguration(environment, customConfigPath) {
+    (0, integrations_1.validateIsIntegrationDirectory)();
+    let configuration;
+    let fileContent;
+    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');
+    }
+    catch (error) {
+        throw new errors_1.NoConfigurationFileError();
+    }
+    try {
+        configuration = JSON.parse(fileContent);
+    }
+    catch (error) {
+        throw new errors_1.ConfigurationMalformed();
+    }
+    // Initialize the required structure in the configuration.
+    if (!configuration.testAccounts) {
+        configuration.testAccounts = { development: {} };
+    }
+    if (!configuration.testAccounts.development) {
+        configuration.testAccounts.development = {};
+    }
+    for (const authorization of configuration.authorizations ?? []) {
+        if (authorization.oauth2) {
+            if (!authorization.oauth2.grantType) {
+                authorization.oauth2.grantType = configurationTypes_1.GrantType.AUTHORIZATION_CODE;
+            }
+            if (!authorization.oauth2.requestContentType) {
+                authorization.oauth2.requestContentType = configurationTypes_1.RequestContentType.URL_ENCODED;
+            }
+            if (!authorization.oauth2.responseContentType) {
+                authorization.oauth2.responseContentType = configurationTypes_1.RequestContentType.JSON;
+            }
+        }
+    }
+    await validateConfiguration(configuration);
+    return configuration;
+}
+exports.getConfiguration = getConfiguration;
+/**
+ * Write the configuration to the default configuration file.
+ */
+async function writeConfiguration(configuration) {
+    (0, integrations_1.validateIsIntegrationDirectory)();
+    await validateConfiguration(configuration);
+    await fs.promises.writeFile(getConfigurationPath(globalConfiguration_1.Environment.Production), JSON.stringify(configuration, null, 2));
+}
+exports.writeConfiguration = writeConfiguration;
+async function writeTestAccount(configuration, account, accountName) {
+    // istanbul ignore next
+    if (accountName !== 'development' && accountName !== 'compliance') {
+        throw new Error('Invalid account name');
+    }
+    configuration.testAccounts = configuration.testAccounts ?? {};
+    configuration.testAccounts[accountName] = account;
+    await writeConfiguration(configuration);
+}
+exports.writeTestAccount = writeTestAccount;
+async function validateConfiguration(configuration) {
+    const directory = `${__dirname}/../../schemas`;
+    const files = await fs.promises.readdir(directory);
+    const jsonFiles = files.filter(filename => filename.endsWith('.json'));
+    const schemasContent = await Promise.all(jsonFiles.map(filename => fs.promises.readFile(`${directory}/${filename}`, 'utf8')));
+    const schemas = schemasContent.map(content => JSON.parse(content));
+    const spec = new ajv_1.default({ schemas, keywords: ['tsEnumNames'], allErrors: true });
+    (0, ajv_formats_1.default)(spec);
+    const schema = 'https://unito.io/integration_cli/configuration.schema.json';
+    const validate = spec.getSchema(schema);
+    if (!validate) {
+        throw new Error(`Schema ${schema} not found'`);
+    }
+    // ESLint seems confused about this AJV function and thinks it is async.
+    // eslint-disable-next-line @typescript-eslint/no-floating-promises
+    validate(configuration);
+    if (validate.errors) {
+        throw new errors_1.ConfigurationInvalid('Your configuration file is invalid!', validate.errors, (0, better_ajv_errors_1.default)(schema, configuration, validate.errors, { indent: 2 }));
+    }
+    // Validate test accounts.
+    if (configuration.testAccounts && configuration.authorizations?.length) {
+        for (const [name, account] of Object.entries(configuration.testAccounts)) {
+            if (Object.keys(account).length) {
+                validateTestAccount(name, account, configuration.authorizations, spec);
+            }
+        }
+    }
+}
+function validateTestAccount(credentialName, credential, authorizationDefinitions, spec) {
+    const authorizationSchemas = authorizationDefinitions.map(constructAuthorizationSchema);
+    const schema = { anyOf: authorizationSchemas };
+    const validate = spec.compile(schema);
+    validate(credential);
+    if (validate.errors) {
+        throw new errors_1.ConfigurationInvalid(`Your testAccount ${credentialName} is invalid!`, validate.errors, (0, better_ajv_errors_1.default)(schema, credential, validate.errors, { indent: 2 }));
+    }
+}
+function constructAuthorizationSchema(authorizationDefinition) {
+    const authorizationSchema = {
+        type: 'object',
+        additionalProperties: true,
+    };
+    if (authorizationDefinition.method === configurationTypes_1.Method.OAUTH2) {
+        authorizationSchema.properties = {
+            accessToken: {
+                type: 'string',
+            },
+            refreshToken: {
+                type: 'string',
+            },
+            expiresIn: {
+                type: 'number',
+            },
+            tokenType: {
+                type: 'string',
+            },
+            scope: {
+                type: 'string',
+            },
+            oauth2ExtraParameters: {
+                type: 'object',
+                additionalProperties: true,
+            },
+        };
+        authorizationSchema.required = ['accessToken'];
+    }
+    const authorizationVariables = Object.entries(authorizationDefinition.variables ?? {});
+    if (authorizationVariables.length) {
+        const variableProperties = Object.fromEntries(authorizationVariables.map(([name, definition]) => [
+            name,
+            {
+                // Sanitize Type to compile schema
+                type: ['boolean', 'number'].includes(definition.type) ? definition.type : 'string',
+                format: definition.format,
+                pattern: definition.pattern,
+            },
+        ]));
+        authorizationSchema.properties = { ...authorizationSchema.properties, ...variableProperties };
+        const required = Array.from(new Set(authorizationVariables.filter(([, definition]) => definition.required).map(([name]) => name)));
+        if (required.length) {
+            (authorizationSchema.required ??= []).push(...required);
+        }
+    }
+    return authorizationSchema;
+}

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

@@ -0,0 +1,5 @@
+import { Configuration } from '../configurationTypes';
+import * as GlobalConfiguration from './globalConfiguration';
+import { CredentialScope } from './configuration';
+export declare function decryptTestAccountCredentials(configuration: Configuration, environment: GlobalConfiguration.Environment, testAccount: CredentialScope, configDir: string): Promise<Record<string, unknown>>;
+export declare function decryptSecrets(configuration: Configuration, environment: GlobalConfiguration.Environment, configDir: string): Promise<Record<string, unknown>>;

package/dist/src/resources/decryption.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decryptSecrets = exports.decryptTestAccountCredentials = 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 configuration_1 = require("./configuration");
+const integrationsPlatform_2 = require("../services/integrationsPlatform");
+async function decryptTestAccountCredentials(configuration, environment, testAccount, configDir) {
+    const credentials = configuration.testAccounts?.[testAccount];
+    if (!credentials) {
+        return {};
+    }
+    // Get encrypted credential entries
+    const encryptedEntries = Object.entries(credentials).filter((entry) => typeof entry[1] === 'string' && entry[1].startsWith(configuration_1.ENCRYPTION_PREFIX));
+    if (!encryptedEntries.length) {
+        return credentials;
+    }
+    // Copy credentials to avoid mutating the configuration.
+    const decryptedCredentials = structuredClone(credentials);
+    const globalConfiguration = await GlobalConfiguration.read(configDir);
+    try {
+        await (0, integrationsPlatform_1.validateAuthenticated)(globalConfiguration, environment);
+    }
+    catch (err) {
+        throw new errors_1.DecryptionAuthenticationError('credentials');
+    }
+    for (const [key, encryptedCredential] of encryptedEntries) {
+        try {
+            decryptedCredentials[key] = (await (0, integrationsPlatform_2.decryptData)(configuration.name, encryptedCredential)).decryptedData;
+        }
+        catch (err) {
+            throw new errors_1.EntryDecryptionError(key, encryptedCredential, environment);
+        }
+    }
+    return decryptedCredentials;
+}
+exports.decryptTestAccountCredentials = decryptTestAccountCredentials;
+async function decryptSecrets(configuration, environment, configDir) {
+    if (!Object.entries(configuration.secrets ?? {}).length) {
+        return {};
+    }
+    const globalConfiguration = await GlobalConfiguration.read(configDir);
+    try {
+        await (0, integrationsPlatform_1.validateAuthenticated)(globalConfiguration, environment);
+    }
+    catch (err) {
+        throw new errors_1.DecryptionAuthenticationError('secrets');
+    }
+    const decryptedSecrets = {};
+    for (const [key, encryptedSecret] of Object.entries(configuration.secrets ?? {})) {
+        try {
+            decryptedSecrets[key] = (await (0, integrationsPlatform_2.decryptData)(configuration.name, encryptedSecret)).decryptedData;
+        }
+        catch (err) {
+            throw new errors_1.EntryDecryptionError(key, encryptedSecret, environment);
+        }
+    }
+    return decryptedSecrets;
+}
+exports.decryptSecrets = decryptSecrets;

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

@@ -0,0 +1,2 @@
+/// <reference types="node" />
+export declare function getFileBuffer(fileName: string, maxFileSize: number): Promise<Buffer | null>;

package/dist/src/resources/fileSystem.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFileBuffer = void 0;
+const tslib_1 = require("tslib");
+const promises_1 = tslib_1.__importDefault(require("fs/promises"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const errors_1 = require("../errors");
+async function getFileBuffer(fileName, maxFileSize) {
+    const filePath = path_1.default.resolve(fileName);
+    try {
+        await promises_1.default.access(filePath);
+    }
+    catch (error) {
+        return null;
+    }
+    const fileStat = await promises_1.default.stat(filePath);
+    if (fileStat.size > maxFileSize) {
+        throw new errors_1.FileSizeExceeded(`File exceeds the size limit: ${maxFileSize}`);
+    }
+    return promises_1.default.readFile(filePath);
+}
+exports.getFileBuffer = getFileBuffer;

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

@@ -0,0 +1,13 @@
+export interface Configuration {
+    apiKey: string | undefined;
+    apiKeyStaging: string | undefined;
+    apiKeyLocal: string | undefined;
+}
+export declare enum Environment {
+    Local = "local",
+    Staging = "staging",
+    Production = "production"
+}
+export declare function getDefault(): Configuration;
+export declare function read(baseDir: string): Promise<Configuration>;
+export declare function write(baseDir: string, configuration: Configuration): Promise<void>;

package/dist/src/resources/globalConfiguration.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.write = exports.read = exports.getDefault = exports.Environment = void 0;
+const tslib_1 = require("tslib");
+const fs_1 = tslib_1.__importDefault(require("fs"));
+const path_1 = tslib_1.__importDefault(require("path"));
+var Environment;
+(function (Environment) {
+    Environment["Local"] = "local";
+    Environment["Staging"] = "staging";
+    Environment["Production"] = "production";
+})(Environment || (exports.Environment = Environment = {}));
+function getDefault() {
+    return {
+        apiKey: undefined,
+        apiKeyStaging: undefined,
+        apiKeyLocal: undefined,
+    };
+}
+exports.getDefault = getDefault;
+async function read(baseDir) {
+    await fs_1.default.promises.mkdir(path_1.default.dirname(getConfigurationPath(baseDir)), { recursive: true });
+    let configuration;
+    try {
+        const file = await fs_1.default.promises.readFile(getConfigurationPath(baseDir), 'utf-8');
+        configuration = JSON.parse(file);
+    }
+    catch {
+        configuration = getDefault();
+    }
+    return { ...getDefault(), ...configuration };
+}
+exports.read = read;
+async function write(baseDir, configuration) {
+    await fs_1.default.promises.mkdir(path_1.default.dirname(getConfigurationPath(baseDir)), { recursive: true });
+    await fs_1.default.promises.writeFile(getConfigurationPath(baseDir), JSON.stringify(configuration, null, 2), {
+        encoding: 'utf8',
+        flag: 'w',
+    });
+}
+exports.write = write;
+function getConfigurationPath(baseDir) {
+    return `${baseDir}/configuration.json`;
+}

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

@@ -0,0 +1,2 @@
+export declare function validateIsIntegrationDirectory(): void;
+export declare function isIntegrationDirectory(): boolean;

package/dist/src/resources/integrations.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isIntegrationDirectory = exports.validateIsIntegrationDirectory = void 0;
+const tslib_1 = require("tslib");
+const fs_1 = tslib_1.__importDefault(require("fs"));
+const errors_1 = require("../errors");
+const configuration_1 = require("./configuration");
+function validateIsIntegrationDirectory() {
+    if (!isIntegrationDirectory()) {
+        throw new errors_1.NoIntegrationFoundError();
+    }
+}
+exports.validateIsIntegrationDirectory = validateIsIntegrationDirectory;
+function isIntegrationDirectory() {
+    return fs_1.default.existsSync((0, configuration_1.getConfigurationPath)());
+}
+exports.isIntegrationDirectory = isIntegrationDirectory;

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

@@ -0,0 +1,2 @@
+import * as GlobalConfiguration from './globalConfiguration';
+export declare function validateAuthenticated(globalConfiguration: GlobalConfiguration.Configuration, environment: GlobalConfiguration.Environment): Promise<void>;