@unito/integration-cli/dist/src/services/integrationsPlatform.js

Integration CLI

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.Servers = exports.HttpError = void 0;
exports.setEnvironment = setEnvironment;
exports.getApiKey = getApiKey;
exports.setApiKey = setApiKey;
exports.getProfile = getProfile;
exports.encryptData = encryptData;
exports.decryptData = decryptData;
exports.reencryptData = reencryptData;
exports.getIntegration = getIntegration;
exports.getIntegrationByName = getIntegrationByName;
exports.getIntegrations = getIntegrations;
exports.publishIntegration = publishIntegration;
exports.createIntegration = createIntegration;
exports.inviteUserToIntegration = inviteUserToIntegration;
exports.getIntegrationEvents = getIntegrationEvents;
exports.updateIntegration = updateIntegration;
exports.getCredential = getCredential;
const tslib_1 = require("tslib");
const fs = tslib_1.__importStar(require("fs"));
const IntegrationsPlatform = tslib_1.__importStar(require("./integrationsPlatformClient"));
const globalConfiguration_1 = require("../resources/globalConfiguration");
const { HttpError } = IntegrationsPlatform;
exports.HttpError = HttpError;
exports.Servers = {
    [globalConfiguration_1.Environment.Local]: IntegrationsPlatform.servers.local,
    [globalConfiguration_1.Environment.Staging]: IntegrationsPlatform.servers.staging,
    [globalConfiguration_1.Environment.Production]: IntegrationsPlatform.servers.production,
};
function setEnvironment(environment) {
    IntegrationsPlatform.defaults.fetch = fetch;
    IntegrationsPlatform.defaults.baseUrl = exports.Servers[environment];
}
function getApiKey() {
    const header = IntegrationsPlatform.defaults.headers?.Authorization?.toString();
    return header?.split(' ')?.at(1);
}
function setApiKey(apiKey) {
    if (apiKey) {
        IntegrationsPlatform.defaults.headers = { Authorization: `Bearer ${apiKey}` };
    }
    else {
        IntegrationsPlatform.defaults.headers = {};
    }
}
async function getProfile() {
    return IntegrationsPlatform.getProfile();
}
async function encryptData(integrationName, data, sensitive) {
    return IntegrationsPlatform.encryptData({
        integrationName,
        data,
        sensitive,
    });
}
async function decryptData(integrationName, data) {
    return IntegrationsPlatform.decryptData({
        integrationName,
        data,
    });
}
async function reencryptData(integrationName, encryptedData, newIntegrationName) {
    return IntegrationsPlatform.reencryptData({
        integrationName,
        encryptedData,
        newIntegrationName,
    });
}
async function getIntegration(integrationId) {
    return IntegrationsPlatform.getIntegrationById(integrationId);
}
async function getIntegrationByName(integrationName) {
    return IntegrationsPlatform.getIntegrationByName(integrationName);
}
async function getIntegrations() {
    const integrations = [];
    let page;
    const limit = 100;
    let nextPageOffset = 0;
    do {
        page = await IntegrationsPlatform.getIntegrations({
            pagination: { offset: nextPageOffset, limit },
        });
        nextPageOffset += limit;
        integrations.push(...page.data);
    } while (page.data.length >= limit);
    return integrations;
}
async function publishIntegration(archivePath) {
    const file = fs.readFileSync(archivePath);
    const blob = new Blob([file], { type: 'binary' });
    return await IntegrationsPlatform.publishIntegration({ file: blob });
}
async function createIntegration(configuration) {
    // The creation of an integration is kept to its minimal required fields...
    const integration = await IntegrationsPlatform.createIntegration({ name: configuration.name });
    // ... as all other non-required fields are updated here.
    return updateIntegration(integration.id, configuration);
}
async function inviteUserToIntegration(integrationId, email) {
    await IntegrationsPlatform.inviteUser(integrationId, { email });
}
async function getIntegrationEvents(integrationId, options = {}) {
    const { data: events } = await IntegrationsPlatform.getIntegrationEvents(integrationId, options);
    return events;
}
async function updateIntegration(integrationId, configuration) {
    const current = await IntegrationsPlatform.getIntegrationById(integrationId);
    // Create authorizations.
    const authorizationsToCreate = configuration.authorizations
        ?.filter(configAuthorization => !current.authorizations.some(platformAuthorization => platformAuthorization.name === configAuthorization.name))
        ?.map(configAuthorization => {
        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
        // @ts-ignore schema mismatch between the CLI and the platform (but fine at runtime).
        const authorizationToCreate = {
            ...configAuthorization,
            archived: false,
        };
        return authorizationToCreate;
    }) ?? [];
    // Archive authorizations.
    const authorizationsToArchive = current.authorizations
        .filter(platformAuthorization => !configuration.authorizations?.some(configAuthorization => platformAuthorization.name === configAuthorization.name))
        .map(platformAuthorization => {
        const authorizationToArchive = {
            ...platformAuthorization,
            archived: true,
        };
        return authorizationToArchive;
    });
    // Update authorizations.
    const authorizationsToUpdate = current.authorizations
        .filter(platformAuthorization => configuration.authorizations?.some(configAuthorization => platformAuthorization.name === configAuthorization.name))
        .map(platformAuthorization => {
        const configAuthorization = configuration.authorizations?.find(authorization => platformAuthorization.name === authorization.name);
        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
        // @ts-ignore schema mismatch between the CLI and the platform (but fine at runtime).
        const authorizationToUpdate = {
            id: platformAuthorization.id,
            ...(configAuthorization ?? {}),
            archived: false,
        };
        return authorizationToUpdate;
    });
    return await IntegrationsPlatform.updateIntegration(current.id, {
        baseUrl: configuration.baseUrl,
        graphRelativeUrl: configuration.graphRelativeUrl ?? '/',
        credentialAccountRelativeUrl: configuration.credentialAccountRelativeUrl ?? '/me',
        webhookParsingRelativeUrl: configuration.webhookParsingRelativeUrl,
        webhookSubscriptionsRelativeUrl: configuration.webhookSubscriptionsRelativeUrl,
        webhookAcknowledgeRelativeUrl: configuration.webhookAcknowledgeRelativeUrl,
        authorizations: authorizationsToCreate.concat(authorizationsToArchive).concat(authorizationsToUpdate),
        secrets: configuration.secrets,
        ui: configuration.ui,
        archived: configuration.archived,
    });
}
async function getCredential(credentialId) {
    return IntegrationsPlatform.getCredentialById(credentialId);
}