streamby-core 0.13.0 → 0.15.0

package/dist/middleware/createRouter.js

@@ -15,13 +15,27 @@ function isProjectMember(project, userId) {
 function createStreamByRouter(config) {
     const router = express_1.default.Router();
     const adapter = config.adapter || (0, createStorageProvider_1.createStorageProvider)(config.storageProviders);
-    const projectProvider = config.projectProvider || (() => {
-        if (!config.databases) {
-            throw new Error('Either "projectProvider" or "databases" must be provided.');
-        }
-        const dbResult = (0, createDatabaseProvider_1.createDatabaseProvider)(config.databases, adapter);
-        return dbResult.projectProvider;
-    })();
+    const projectProviders = {};
+    let exportProvider;
+    let exportCollectionProvider;
+    if (config.databases) {
+        const db = (0, createDatabaseProvider_1.createDatabaseProvider)(config.databases, adapter);
+        projectProviders.nosql = db.projectProviders.nosql;
+        projectProviders.sql = db.projectProviders.sql;
+        exportProvider = db.exportProvider;
+        exportCollectionProvider = db.exportCollectionProvider;
+    }
+    else {
+        projectProviders.default = config.projectProvider;
+        exportProvider = config.exportProvider;
+        exportCollectionProvider = config.exportCollectionProvider;
+    }
+    if (!projectProviders.nosql && !projectProviders.sql) {
+        throw new Error('Project provider is not initialized. Please check your database configuration.');
+    }
+    if (!exportProvider) {
+        throw new Error('Export provider is not initialized. Please check your database configuration.');
+    }
     router.get('/auth', async (req, res) => {
         try {
             const auth = await config.authProvider(req);
@@ -31,6 +45,25 @@ function createStreamByRouter(config) {
             res.status(401).json({ logged: false });
         }
     });
+    router.get('/databases', async (req, res) => {
+        try {
+            const auth = await config.authProvider(req);
+            if (!auth) {
+                return res.status(401).json({ error: 'Unauthorized' });
+            }
+            const databases = [];
+            if (projectProviders.nosql) {
+                databases.push({ name: "NoSQL (Mongo)", value: "nosql" });
+            }
+            if (projectProviders.sql) {
+                databases.push({ name: "SQL (Prisma)", value: "sql" });
+            }
+            res.status(200).json({ databases });
+        }
+        catch (err) {
+            res.status(500).json({ error: 'Failed to get databases' });
+        }
+    });
     router.get('/upload-project-image-url/:id', async (req, res) => {
         try {
             const auth = await config.authProvider(req);
@@ -59,7 +92,11 @@ function createStreamByRouter(config) {
                 return res.status(400).json({ error: 'Missing projectId' });
             }
             await (0, file_1.deleteProjectImage)(adapter, projectId);
-            const updated = await projectProvider.update(projectId, { image: '' });
+            const provider = await getProjectProvider(projectId);
+            if (!provider) {
+                return res.status(404).json({ error: 'Project not found' });
+            }
+            const updated = await provider.update(projectId, { image: '' });
             res.status(201).json(updated);
         }
         catch (err) {
@@ -80,31 +117,62 @@ function createStreamByRouter(config) {
             res.status(500).json({ error: 'Failed to list files', details: err });
         }
     });
-    router.get('/projects/archived', async (req, res) => {
-        try {
-            const auth = await config.authProvider(req);
-            const archivedProjects = await projectProvider.listArchived(auth.userId);
-            res.json({ projects: archivedProjects });
+    async function getProjectProvider(projectId, dbType) {
+        if (dbType) {
+            const specificProvider = projectProviders[dbType];
+            if (specificProvider) {
+                try {
+                    const project = await specificProvider.getById(projectId, true);
+                    if (project)
+                        return specificProvider;
+                }
+                catch (error) { /* ignore */ }
+            }
         }
-        catch (err) {
-            res.status(500).json({ error: 'Failed to list archived projects', details: err });
+        // Fallback to searching all providers if dbType is not provided or project not found in specific dbType
+        if (projectProviders.nosql) {
+            try {
+                const project = await projectProviders.nosql.getById(projectId, true);
+                if (project)
+                    return projectProviders.nosql;
+            }
+            catch (error) { /* ignore */ }
         }
-    });
-    router.get('/projects/:id', async (req, res) => {
+        if (projectProviders.sql) {
+            try {
+                const project = await projectProviders.sql.getById(projectId, true);
+                if (project)
+                    return projectProviders.sql;
+            }
+            catch (error) { /* ignore */ }
+        }
+        if (projectProviders.default) {
+            try {
+                const project = await projectProviders.default.getById(projectId, true);
+                if (project)
+                    return projectProviders.default;
+            }
+            catch (error) { /* ignore */ }
+        }
+        return null;
+    }
+    router.get('/projects', async (req, res) => {
         try {
             const auth = await config.authProvider(req);
-            const projectId = req.params.id;
-            const project = await projectProvider.getById(projectId);
-            if (!project) {
-                return res.status(404).json({ error: 'Project not found' });
+            const projects = [];
+            if (projectProviders.nosql) {
+                projects.push(...await projectProviders.nosql.list(auth.userId));
             }
-            if (!isProjectMember(project, auth.userId)) {
-                return res.status(403).json({ error: 'Unauthorized project access' });
+            if (projectProviders.sql) {
+                projects.push(...await projectProviders.sql.list(auth.userId));
             }
-            res.json({ project });
+            if (projectProviders.default) {
+                projects.push(...await projectProviders.default.list(auth.userId));
+            }
+            res.json({ projects });
         }
         catch (err) {
-            res.status(500).json({ error: 'Failed to fetch project', details: err.message });
+            res.status(500).json({ error: 'Failed to list projects', details: err });
         }
     });
     router.post('/projects/create', async (req, res) => {
@@ -113,8 +181,13 @@ function createStreamByRouter(config) {
             if (auth.role !== 'admin' && auth.role !== 'editor') {
                 return res.status(403).json({ error: 'Permission denied' });
             }
-            const { name, description } = req.body;
-            const newProject = await projectProvider.create({
+            const { name, description, dbType } = req.body;
+            const provider = dbType ? projectProviders[dbType] : projectProviders.default || projectProviders.nosql || projectProviders.sql;
+            if (!provider) {
+                return res.status(400).json({ error: 'Invalid dbType' });
+            }
+            const newProject = await provider.create({
+                dbType: dbType || 'nosql',
                 name,
                 description: description || '',
                 members: [{ userId: auth.userId, role: "admin" }]
@@ -125,6 +198,28 @@ function createStreamByRouter(config) {
             res.status(500).json({ error: 'Failed to create project', details: err.message });
         }
     });
+    router.get('/projects/:id', async (req, res) => {
+        try {
+            const auth = await config.authProvider(req);
+            const projectId = req.params.id;
+            const dbType = req.query.dbType;
+            const projectProvider = await getProjectProvider(projectId, dbType);
+            if (!projectProvider) {
+                return res.status(404).json({ error: 'Project not found' });
+            }
+            const project = await projectProvider.getById(projectId, true);
+            if (!project) {
+                return res.status(404).json({ error: 'Project not found' });
+            }
+            if (!isProjectMember(project, auth.userId)) {
+                return res.status(403).json({ error: 'Unauthorized project access' });
+            }
+            res.json({ project });
+        }
+        catch (err) {
+            res.status(500).json({ error: 'Failed to fetch project', details: err.message });
+        }
+    });
     router.patch('/projects/:id', async (req, res) => {
         try {
             const auth = await config.authProvider(req);
@@ -133,7 +228,11 @@ function createStreamByRouter(config) {
             }
             const projectId = req.params.id;
             const updates = req.body;
-            const project = await projectProvider.getById(projectId);
+            const projectProvider = await getProjectProvider(projectId);
+            if (!projectProvider) {
+                return res.status(404).json({ error: 'Project not found' });
+            }
+            const project = await projectProvider.getById(projectId, true);
             if (!project) {
                 return res.status(404).json({ error: 'Project not found' });
             }
@@ -154,7 +253,11 @@ function createStreamByRouter(config) {
         try {
             const auth = await config.authProvider(req);
             const projectId = req.params.id;
-            const project = await projectProvider.getById(projectId);
+            const projectProvider = await getProjectProvider(projectId);
+            if (!projectProvider) {
+                return res.status(404).json({ error: 'Project not found' });
+            }
+            const project = await projectProvider.getById(projectId, true);
             if (!project) {
                 return res.status(404).json({ error: 'Project not found' });
             }
@@ -168,48 +271,115 @@ function createStreamByRouter(config) {
             res.status(500).json({ error: 'Failed to delete project', details: err.message });
         }
     });
-    router.get('/projects', async (req, res) => {
+    router.patch('/projects/:id/archive', async (req, res) => {
         try {
             const auth = await config.authProvider(req);
-            const projects = await projectProvider.list(auth.userId);
-            res.json({ projects });
+            const projectId = req.params.id;
+            const projectProvider = await getProjectProvider(projectId);
+            if (!projectProvider) {
+                return res.status(404).json({ error: 'Project not found' });
+            }
+            const project = await projectProvider.getById(projectId, true);
+            if (!project || !isProjectMember(project, auth.userId)) {
+                return res.status(403).json({ error: 'Unauthorized project access' });
+            }
+            const result = await projectProvider.archive(projectId, auth.userId);
+            res.status(200).json(result);
         }
         catch (err) {
-            res.status(500).json({ error: 'Failed to list projects', details: err });
+            res.status(500).json({ error: 'Failed to archive project', details: err.message });
         }
     });
-    router.patch('/projects/:id/archive', async (req, res) => {
+    router.patch('/projects/:id/unarchive', async (req, res) => {
         try {
             const auth = await config.authProvider(req);
             const projectId = req.params.id;
-            const project = await projectProvider.getById(projectId);
+            const projectProvider = await getProjectProvider(projectId);
+            if (!projectProvider) {
+                return res.status(404).json({ error: 'Project not found' });
+            }
+            const project = await projectProvider.getById(projectId, true);
             if (!project || !isProjectMember(project, auth.userId)) {
                 return res.status(403).json({ error: 'Unauthorized project access' });
             }
-            await projectProvider.archive(projectId, auth.userId);
-            const projects = await projectProvider.list(auth.userId);
-            const archivedProjects = await projectProvider.listArchived(auth.userId);
-            res.status(200).json({ success: true, projects, archivedProjects });
+            const result = await projectProvider.unarchive(projectId, auth.userId);
+            res.status(200).json(result);
         }
         catch (err) {
-            res.status(500).json({ error: 'Failed to archive project', details: err.message });
+            res.status(500).json({ error: 'Failed to unarchive project', details: err.message });
         }
     });
-    router.patch('/projects/:id/unarchive', async (req, res) => {
+    router.get('/projects/:id/exports/:export_id', async (req, res) => {
         try {
             const auth = await config.authProvider(req);
             const projectId = req.params.id;
-            const project = await projectProvider.getById(projectId);
+            const exportId = req.params.export_id;
+            const projectProvider = await getProjectProvider(projectId);
+            if (!projectProvider) {
+                return res.status(404).json({ error: 'Project not found' });
+            }
+            const project = await projectProvider.getById(projectId, true);
+            if (!project) {
+                return res.status(404).json({ error: 'Project not found' });
+            }
+            if (!isProjectMember(project, auth.userId)) {
+                return res.status(403).json({ error: 'Unauthorized access' });
+            }
+            const data = await exportProvider.getById(exportId);
+            res.json({ data });
+        }
+        catch (err) {
+            res.status(500).json({ error: 'Failed to fetch export data', details: err.message });
+        }
+    });
+    router.post('/projects/:id/exports', async (req, res) => {
+        try {
+            const auth = await config.authProvider(req);
+            const projectId = req.params.id;
+            const { name, description, collectionName } = req.body;
+            if (!name || !collectionName) {
+                return res.status(400).json({ error: 'Missing export name or collectionName' });
+            }
+            const projectProvider = await getProjectProvider(projectId);
+            if (!projectProvider) {
+                return res.status(404).json({ error: 'Project not found' });
+            }
+            const project = await projectProvider.getById(projectId, true);
             if (!project || !isProjectMember(project, auth.userId)) {
                 return res.status(403).json({ error: 'Unauthorized project access' });
             }
-            await projectProvider.unarchive(projectId, auth.userId);
-            const projects = await projectProvider.list(auth.userId);
-            const archivedProjects = await projectProvider.listArchived(auth.userId);
-            res.status(200).json({ success: true, projects, archivedProjects });
+            const newExport = await exportProvider.create({
+                name,
+                description,
+                collectionName,
+                projectId
+            });
+            await projectProvider.addExportToProject(projectId, newExport.id);
+            res.status(201).json({ data: newExport });
         }
         catch (err) {
-            res.status(500).json({ error: 'Failed to unarchive project', details: err.message });
+            res.status(500).json({ error: 'Failed to create export', details: err.message });
+        }
+    });
+    router.get('/projects/:id/members', async (req, res) => {
+        try {
+            const auth = await config.authProvider(req);
+            const projectId = req.params.id;
+            const projectProvider = await getProjectProvider(projectId);
+            if (!projectProvider) {
+                return res.status(404).json({ error: 'Project not found' });
+            }
+            const project = await projectProvider.getById(projectId, true);
+            if (!project) {
+                return res.status(404).json({ error: 'Project not found' });
+            }
+            if (!isProjectMember(project, auth.userId)) {
+                return res.status(403).json({ error: 'Unauthorized project access' });
+            }
+            res.json({ members: project.members });
+        }
+        catch (err) {
+            res.status(500).json({ error: 'Failed to fetch project members', details: err.message });
         }
     });
     return router;

package/dist/models/ExportCollection.d.ts

@@ -0,0 +1,54 @@
+import mongoose from 'mongoose';
+export declare function initExportCollectionModel(connection: mongoose.Connection): mongoose.Model<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    name: string;
+    entries: mongoose.Types.DocumentArray<{}, mongoose.Types.Subdocument<unknown, any, {}>>;
+    projectId: mongoose.Types.ObjectId;
+}, {}, {}, {}, mongoose.Document<unknown, {}, {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    name: string;
+    entries: mongoose.Types.DocumentArray<{}, mongoose.Types.Subdocument<unknown, any, {}>>;
+    projectId: mongoose.Types.ObjectId;
+}, {}> & {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    name: string;
+    entries: mongoose.Types.DocumentArray<{}, mongoose.Types.Subdocument<unknown, any, {}>>;
+    projectId: mongoose.Types.ObjectId;
+} & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}, mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, {}, {}, {}, {}, {
+    timestamps: true;
+}, {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    name: string;
+    entries: mongoose.Types.DocumentArray<{}, mongoose.Types.Subdocument<unknown, any, {}>>;
+    projectId: mongoose.Types.ObjectId;
+}, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    name: string;
+    entries: mongoose.Types.DocumentArray<{}, mongoose.Types.Subdocument<unknown, any, {}>>;
+    projectId: mongoose.Types.ObjectId;
+}>, {}> & mongoose.FlatRecord<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    name: string;
+    entries: mongoose.Types.DocumentArray<{}, mongoose.Types.Subdocument<unknown, any, {}>>;
+    projectId: mongoose.Types.ObjectId;
+}> & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}>>;

package/dist/models/ExportCollection.js

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initExportCollectionModel = initExportCollectionModel;
+const mongoose_1 = __importDefault(require("mongoose"));
+const ExportEntrySchema = new mongoose_1.default.Schema({}, { strict: false, _id: false });
+const ExportCollectionSchema = new mongoose_1.default.Schema({
+    projectId: { type: mongoose_1.default.Schema.Types.ObjectId, ref: 'Project', required: true },
+    name: { type: String, required: true }, // e.g., "experience"
+    entries: [ExportEntrySchema],
+}, {
+    timestamps: true,
+});
+ExportCollectionSchema.index({ projectId: 1, name: 1 }, { unique: true });
+function initExportCollectionModel(connection) {
+    return connection.model('ExportCollection', ExportCollectionSchema);
+}

package/dist/providers/createDatabaseProvider.d.ts

@@ -1,12 +1,72 @@
 import mongoose from 'mongoose';
-import { StorageAdapter } from '../types';
-type SupportedDbType = 'mongo';
-export interface DatabaseCredential {
-    dbType: SupportedDbType;
-    connectionString: string;
-}
+import { StorageAdapter, DatabaseCredential } from '../types';
+import { PrismaClient } from '@prisma/client';
 export declare function createDatabaseProvider(databases: DatabaseCredential[], adapter: StorageAdapter): {
-    projectProvider: import("../types").ProjectProvider;
-    mongoConnection: mongoose.Connection;
+    exportProvider: import("../types").ExportProvider | undefined;
+    projectProviders: {
+        nosql: import("../types").ProjectProvider | undefined;
+        sql: import("../types").ProjectProvider | undefined;
+    };
+    exportCollectionProvider: {
+        getById(id: string): Promise<({
+            entries: {
+                id: string;
+                exportCollectionId: string;
+                key: string;
+                value: string;
+            }[];
+        } & {
+            id: string;
+            name: string;
+            createdAt: Date;
+            updatedAt: Date;
+            projectId: string;
+        }) | null>;
+        create(data: {
+            projectId: string;
+            name: string;
+            entries: Array<{
+                key: string;
+                value: string;
+            }>;
+        }): Promise<{
+            entries: {
+                id: string;
+                exportCollectionId: string;
+                key: string;
+                value: string;
+            }[];
+        } & {
+            id: string;
+            name: string;
+            createdAt: Date;
+            updatedAt: Date;
+            projectId: string;
+        }>;
+        update(id: string, data: {
+            name?: string;
+            entries?: Array<{
+                key: string;
+                value: string;
+            }>;
+        }): Promise<{
+            entries: {
+                id: string;
+                exportCollectionId: string;
+                key: string;
+                value: string;
+            }[];
+        } & {
+            id: string;
+            name: string;
+            createdAt: Date;
+            updatedAt: Date;
+            projectId: string;
+        }>;
+        delete(id: string): Promise<{
+            success: boolean;
+        }>;
+    } | undefined;
+    mongoConnection: mongoose.Connection | undefined;
+    prismaClient: PrismaClient<import(".prisma/client").Prisma.PrismaClientOptions, never, import("@prisma/client/runtime/library").DefaultArgs> | undefined;
 };
-export {};

package/dist/providers/createDatabaseProvider.js

@@ -6,21 +6,53 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createDatabaseProvider = createDatabaseProvider;
 const mongoose_1 = __importDefault(require("mongoose"));
 const initProjectModel_1 = require("../db/initProjectModel");
+const initUserModel_1 = require("../db/initUserModel");
+const mongoExportProvider_1 = require("./mongoExportProvider");
 const mongoProjectProvider_1 = require("./mongoProjectProvider");
+const initExportModel_1 = require("../db/initExportModel");
+const createPrismaProvider_1 = require("./createPrismaProvider");
+const prismaExportProvider_1 = require("./prismaExportProvider");
+const prismaProjectProvider_1 = require("./prismaProjectProvider");
+const prismaExportCollectionProvider_1 = require("./prismaExportCollectionProvider");
 function createDatabaseProvider(databases, adapter) {
-    // Solo una conexión mongo por ahora
-    const mongoConfig = databases.find((db) => db.dbType === 'mongo');
-    if (!mongoConfig) {
-        throw new Error('No MongoDB configuration provided. Mongo is currently required.');
+    let mongoConnection;
+    let prismaClient;
+    const mongoConfig = databases.find((db) => db.dbType === 'nosql');
+    if (mongoConfig) {
+        if (!mongoConfig.connectionString) {
+            throw new Error('MongoDB connection string is required for mongo dbType.');
+        }
+        mongoConnection = mongoose_1.default.createConnection(mongoConfig.connectionString, {
+            dbName: undefined,
+        });
     }
-    // Conexión a MongoDB
-    const connection = mongoose_1.default.createConnection(mongoConfig.connectionString, {
-        dbName: undefined, // Opcional: podrías extraer el nombre desde la URI si quisieras
-    });
-    const ProjectModel = (0, initProjectModel_1.initProjectModel)(connection);
-    const projectProvider = (0, mongoProjectProvider_1.createMongoProjectProvider)(ProjectModel, adapter);
+    const prismaConfig = databases.find((db) => db.dbType === 'sql');
+    if (prismaConfig) {
+        if (!prismaConfig.connectionString) {
+            throw new Error('Prisma connection string is required for prisma dbType.');
+        }
+        prismaClient = (0, createPrismaProvider_1.createPrismaProvider)(prismaConfig.connectionString) || undefined;
+    }
+    if (!mongoConnection && !prismaClient) {
+        throw new Error('At least one database configuration (mongo or prisma) is required.');
+    }
+    // If mongoConnection is not defined, we can't create mongo-based providers
+    const ExportModel = mongoConnection ? (0, initExportModel_1.initExportModel)(mongoConnection) : undefined;
+    const ProjectModel = mongoConnection ? (0, initProjectModel_1.initProjectModel)(mongoConnection) : undefined;
+    const UserModel = mongoConnection ? (0, initUserModel_1.initUserModel)(mongoConnection) : undefined;
+    const mongoExportProvider = ExportModel ? (0, mongoExportProvider_1.createMongoExportProvider)(ExportModel) : undefined;
+    const mongoProjectProvider = ProjectModel && ExportModel ? (0, mongoProjectProvider_1.createMongoProjectProvider)(ProjectModel, ExportModel, adapter) : undefined;
+    const prismaExportProvider = prismaClient ? (0, prismaExportProvider_1.createPrismaExportProvider)(prismaClient) : undefined;
+    const prismaProjectProvider = prismaClient ? (0, prismaProjectProvider_1.createPrismaProjectProvider)(prismaClient, adapter) : undefined;
+    const prismaExportCollectionProvider = prismaClient ? (0, prismaExportCollectionProvider_1.createPrismaExportCollectionProvider)(prismaClient) : undefined;
     return {
-        projectProvider,
-        mongoConnection: connection,
+        exportProvider: mongoExportProvider || prismaExportProvider,
+        projectProviders: {
+            nosql: mongoProjectProvider,
+            sql: prismaProjectProvider,
+        },
+        exportCollectionProvider: prismaExportCollectionProvider, // Solo Prisma tiene este por ahora
+        mongoConnection,
+        prismaClient,
     };
 }

package/dist/providers/createPrismaProvider.d.ts

@@ -0,0 +1,8 @@
+import { PrismaClient } from '@prisma/client';
+export declare function createPrismaProvider(connectionString: string): PrismaClient<{
+    datasources: {
+        db: {
+            url: string;
+        };
+    };
+}, never, import("@prisma/client/runtime/library").DefaultArgs> | null;

package/dist/providers/createPrismaProvider.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPrismaProvider = createPrismaProvider;
+const client_1 = require("@prisma/client");
+function createPrismaProvider(connectionString) {
+    if (!connectionString) {
+        console.warn('Connection string is not provided. Prisma client will not be initialized.');
+        return null;
+    }
+    const prisma = new client_1.PrismaClient({
+        datasources: {
+            db: {
+                url: connectionString,
+            },
+        },
+    });
+    return prisma;
+}

package/dist/providers/mongoExportProvider.d.ts

@@ -0,0 +1,3 @@
+import { Model } from 'mongoose';
+import { ExportProvider } from '../types';
+export declare function createMongoExportProvider(ExportModel: Model<any>): ExportProvider;

package/dist/providers/mongoExportProvider.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMongoExportProvider = createMongoExportProvider;
+function createMongoExportProvider(ExportModel) {
+    return {
+        async getById(exportId) {
+            return await ExportModel.findById(exportId).lean();
+        },
+        async create(data) {
+            return await ExportModel.create(data);
+        }
+    };
+}

package/dist/providers/mongoProjectProvider.d.ts

@@ -1,3 +1,3 @@
 import { ProjectProvider, StorageAdapter } from '../types';
 import { Model } from 'mongoose';
-export declare function createMongoProjectProvider(ProjectModel: Model<any>, adapter: StorageAdapter): ProjectProvider;
+export declare function createMongoProjectProvider(ProjectModel: Model<any>, ExportModel: Model<any>, adapter: StorageAdapter): ProjectProvider;