streamby-core/dist/services/export.js

StreamBy middleware framework for media storage management

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.createExport = createExport;
exports.updateExport = updateExport;
exports.deleteExport = deleteExport;
const manager_1 = require("../models/manager");
const mongodb_1 = require("mongodb");
const connectionManager_1 = require("../adapters/database/connectionManager");
const nosql_1 = require("../adapters/database/nosql");
const sql_1 = require("../adapters/database/sql");
const encryption_1 = require("../utils/encryption");
async function createExport(config, projectId, description, fields, exportName, jsonData, dbType, exportType, isPrivate, allowedOrigin, apiUrl, credentialId, prefix) {
    const targetDb = config.databases?.find(db => db.type === dbType && db.main) ||
        config.databases?.find(db => db.type === dbType);
    if (!targetDb) {
        throw new Error(`Database connection not found for type ${dbType}`);
    }
    const connection = (0, connectionManager_1.getConnection)(targetDb.id);
    let result;
    if (exportType === 'externalApi') {
        if (!apiUrl) {
            throw new Error('API URL is required for externalApi export type.');
        }
        const ProjectModel = (0, manager_1.getModel)('projects', 'nosql');
        const project = await ProjectModel.findOne({ _id: projectId });
        if (!project) {
            throw new Error('Project not found.');
        }
        if (credentialId) {
            if (!(0, encryption_1.isEncryptionKeySet)()) {
                throw new Error('Encryption key is not set. Cannot use encrypted credentials.');
            }
            const credential = project.credentials?.find(cred => cred.id === credentialId);
            if (!credential) {
                throw new Error(`Credential with ID ${credentialId} not found.`);
            }
        }
        if (dbType === 'nosql') {
            result = await (0, nosql_1.createNoSQLRawExportCollection)(connection.client, projectId, exportName, 'GET', null);
        }
        else if (dbType === 'sql') {
            result = await (0, sql_1.createSQLRawExportTable)(connection.client, projectId, exportName, null);
        }
        else {
            throw new Error('Unsupported database type for externalApi export');
        }
    }
    else if (dbType === 'nosql') {
        result = await (0, nosql_1.createNoSQLRawExportCollection)(connection.client, projectId, exportName, 'GET', jsonData);
    }
    else if (dbType === 'sql') {
        result = await (0, sql_1.createSQLRawExportTable)(connection.client, projectId, exportName, jsonData);
    }
    else {
        throw new Error('Unsupported database type');
    }
    // Update the project with the new export reference
    // Assuming project metadata is always in NoSQL (MongoDB)
    const NoSQLProject = (0, manager_1.getModel)('projects', 'nosql');
    await NoSQLProject.update({ _id: projectId }, { $push: { exports: { id: dbType === 'nosql' ? new mongodb_1.ObjectId(result.exportId) : result.exportId, name: exportName, collectionName: result.collectionName, type: exportType, method: 'GET', private: isPrivate, allowedOrigin: allowedOrigin, apiUrl: apiUrl, credentialId: credentialId, prefix: prefix, description: description, fields: fields } } });
    return { ...result, message: `${exportType} export created successfully` };
}
async function updateExport(config, projectId, exportId, description, fields, exportName, collectionName, jsonData, dbType, exportType, isPrivate, allowedOrigin, apiUrl, credentialId, prefix) {
    const targetDb = config.databases?.find(db => db.type === dbType && db.main) ||
        config.databases?.find(db => db.type === dbType);
    if (!targetDb) {
        throw new Error(`Database connection not found for type ${dbType}`);
    }
    const connection = (0, connectionManager_1.getConnection)(targetDb.id);
    let result;
    if (exportType === 'externalApi') {
        if (!apiUrl) {
            throw new Error('API URL is required for externalApi export type.');
        }
        const ProjectModel = (0, manager_1.getModel)('projects', 'nosql');
        const project = await ProjectModel.findOne({ _id: projectId });
        if (!project) {
            throw new Error('Project not found.');
        }
        if (dbType === 'nosql') {
            const db = connection.client.db();
            const updateData = {
                json: jsonData,
                description: description,
                fields: fields,
                updatedAt: new Date(),
                apiUrl: apiUrl,
                credentialId: credentialId,
                prefix: prefix,
            };
            await db.collection(collectionName).updateOne({ _id: new mongodb_1.ObjectId(exportId) }, { $set: updateData });
        }
        else {
            throw new Error('Unsupported database type for externalApi export update');
        }
    }
    else if (dbType === 'nosql') {
        const db = connection.client.db();
        const updateData = {
            json: jsonData,
            description: description,
            fields: fields,
            apiUrl: apiUrl,
            credentialId: credentialId,
            prefix: prefix,
        };
        await db.collection(collectionName).updateOne({ _id: new mongodb_1.ObjectId(exportId) }, { $set: updateData });
    }
    else {
        throw new Error('Unsupported database type for update');
    }
    const NoSQLProject = (0, manager_1.getModel)('projects', 'nosql');
    await NoSQLProject.update({
        _id: new mongodb_1.ObjectId(projectId),
        'exports.id': { $in: [new mongodb_1.ObjectId(exportId), exportId] }
    }, { $set: { 'exports.$.name': exportName, 'exports.$.collectionName': collectionName, 'exports.$.private': isPrivate, 'exports.$.allowedOrigin': allowedOrigin, 'exports.$.apiUrl': apiUrl, 'exports.$.credentialId': credentialId, 'exports.$.prefix': prefix, 'exports.$.description': description, 'exports.$.fields': fields } });
    result = { collectionName, exportId };
    return { ...result, message: `${exportType} export updated successfully` };
}
async function deleteExport(config, projectId, exportId, dbType, collectionName) {
    const targetDb = config.databases?.find(db => db.type === dbType && db.main) ||
        config.databases?.find(db => db.type === dbType);
    if (!targetDb) {
        throw new Error(`Database connection not found for type ${dbType}`);
    }
    const connection = (0, connectionManager_1.getConnection)(targetDb.id);
    if (dbType === 'nosql') {
        const db = connection.client.db();
        await db.collection(collectionName).deleteOne({ _id: new mongodb_1.ObjectId(exportId) });
    }
    else {
        throw new Error('Unsupported database type for delete');
    }
    const NoSQLProject = (0, manager_1.getModel)('projects', 'nosql');
    await NoSQLProject.update({ _id: new mongodb_1.ObjectId(projectId) }, { $pull: { exports: { id: new mongodb_1.ObjectId(exportId) } } });
    return { message: 'Export deleted successfully' };
}