MuDBase/server/db/Integration.ts

import * as api from '../../client/src/api/api';
import Knex from 'knex';
import asJson from '../lib/asJson';
import { DBError, DBErrorKind } from '../endpoints/types';
import { IntegrationDataWithId, IntegrationDataWithSecret, PartialIntegrationData } from '../../client/src/api/api';
import { makeNotFoundError } from './common';

export async function createIntegration(userId: number, integration: api.IntegrationDataWithSecret, knex: Knex): Promise<number> {
    return await knex.transaction(async (trx) => {
        // Create the new integration.
        var integration: any = {
            name: integration.name,
            user: userId,
            type: integration.type,
            details: JSON.stringify(integration.details),
            secretDetails: JSON.stringify(integration.secretDetails),
        }
        const integrationId = (await trx('integrations')
            .insert(integration)
            .returning('id') // Needed for Postgres
        )[0];

        return integrationId;
    })
}

export async function getIntegration(userId: number, id: number, knex: Knex): Promise<api.IntegrationData> {
    const integration = (await knex.select(['id', 'name', 'type', 'details'])
        .from('integrations')
        .where({ 'user': userId, 'id': id }))[0];

    if (integration) {
        const r: api.IntegrationData = {
            mbApi_typename: "integrationData",
            name: integration.name,
            type: integration.type,
            details: asJson(integration.details),
        }
        return r;
    } else {
        throw makeNotFoundError();
    }
}

export async function listIntegrations(userId: number, knex: Knex): Promise<api.IntegrationDataWithId[]> {
    const integrations: api.IntegrationDataWithId[] = (
        await knex.select(['id', 'name', 'type', 'details'])
            .from('integrations')
            .where({ user: userId })
    ).map((object: any) => {
        return {
            mbApi_typename: "integrationData",
            id: object.id,
            name: object.name,
            type: object.type,
            details: asJson(object.details),
        }
    })

    return integrations;
}

export async function deleteIntegration(userId: number, id: number, knex: Knex) {
    await knex.transaction(async (trx) => {
        // Start retrieving the integration itself.
        const integrationId = await trx.select('id')
            .from('integrations')
            .where({ 'user': userId })
            .where({ id: id })
            .then((r: any) => (r && r[0]) ? r[0]['id'] : undefined)

        // Check that we found all objects we need.
        if (!integrationId) {
            throw makeNotFoundError();
        }

        // Delete the integration.
        await trx('integrations')
            .where({ 'user': userId, 'id': integrationId })
            .del();
    })
}

export async function modifyIntegration(userId: number, id: number, integration: PartialIntegrationData, knex: Knex): Promise<void> {
    await knex.transaction(async (trx) => {
        // Start retrieving the integration.
        const integrationId = await trx.select('id')
            .from('integrations')
            .where({ 'user': userId })
            .then((r: any) => (r && r[0]) ? r[0]['id'] : undefined)

        // Check that we found all objects we need.
        if (!integrationId) {
            throw makeNotFoundError();
        }

        // Modify the integration.
        var update: any = {};
        if ("name" in integration) { update["name"] = integration.name; }
        if ("details" in integration) { update["details"] = JSON.stringify(integration.details); }
        if ("type" in integration) { update["type"] = integration.type; }
        if ("secretDetails" in integration) { update["secretDetails"] = JSON.stringify(integration.details); }
        await trx('integrations')
            .where({ 'user': userId, 'id': id })
            .update(update)
    })
}