streamby-core 0.14.0 → 0.16.0

package/dist/mongoose_models/initProjectModel.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initProjectModel = initProjectModel;
+const mongoose_1 = __importDefault(require("mongoose"));
+function initProjectModel(connection) {
+    const folderNodeSchema = new mongoose_1.default.Schema({
+        id: String,
+        name: String,
+        children: [Object],
+    }, { _id: false });
+    const memberSchema = new mongoose_1.default.Schema({
+        userId: { type: mongoose_1.default.Schema.Types.ObjectId, required: true },
+        role: { type: String, enum: ['viewer', 'editor', 'admin'], default: 'viewer' },
+        archived: { type: Boolean, default: false }
+    }, { _id: false });
+    const projectSchema = new mongoose_1.default.Schema({
+        dbType: { type: String, required: true },
+        name: { type: String, required: true },
+        description: { type: String },
+        image: { type: String },
+        folders: [folderNodeSchema],
+        allowUpload: { type: Boolean, default: true },
+        allowSharing: { type: Boolean, default: false },
+        members: [memberSchema],
+        exports: [{ type: mongoose_1.default.Schema.Types.ObjectId, ref: 'Export' }]
+    }, {
+        timestamps: true,
+        collection: 'streamby_projects'
+    });
+    return connection.model('Project', projectSchema);
+}

package/dist/providers/createDatabaseProvider.d.ts

@@ -1,13 +1,2 @@
-import mongoose from 'mongoose';
-import { StorageAdapter } from '../types';
-type SupportedDbType = 'mongo';
-export interface DatabaseCredential {
-    dbType: SupportedDbType;
-    connectionString: string;
-}
-export declare function createDatabaseProvider(databases: DatabaseCredential[], adapter: StorageAdapter): {
-    exportProvider: import("../types").ExportProvider;
-    projectProvider: import("../types").ProjectProvider;
-    mongoConnection: mongoose.Connection;
-};
-export {};
+import { StorageAdapter, DatabaseCredential, DatabaseProviders } from '../types';
+export declare function createDatabaseProvider(databases: DatabaseCredential[], adapter: StorageAdapter): DatabaseProviders;

package/dist/providers/createDatabaseProvider.js

@@ -1,31 +1,36 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 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 createMongooseProvider_1 = require("./createMongooseProvider");
 function createDatabaseProvider(databases, adapter) {
-    const mongoConfig = databases.find((db) => db.dbType === 'mongo');
-    if (!mongoConfig) {
-        throw new Error('No MongoDB configuration provided. Mongo is currently required.');
+    let mongoProviders;
+    let prismaProviders;
+    const mongoConfig = databases.find((db) => db.dbType === 'nosql');
+    if (mongoConfig) {
+        if (!mongoConfig.connectionString) {
+            throw new Error('MongoDB connection string is required for mongo dbType.');
+        }
+        mongoProviders = (0, createMongooseProvider_1.createMongooseProvider)(mongoConfig.connectionString, adapter) || undefined;
+    }
+    const prismaConfig = databases.find((db) => db.dbType === 'sql');
+    if (prismaConfig) {
+        if (!prismaConfig.connectionString) {
+            throw new Error('Prisma connection string is required for prisma dbType.');
+        }
+        prismaProviders = (0, createPrismaProvider_1.createPrismaProvider)(prismaConfig.connectionString, adapter) || undefined;
+    }
+    if (!mongoProviders && !prismaProviders) {
+        throw new Error('At least one database configuration (mongo or prisma) is required.');
     }
-    const connection = mongoose_1.default.createConnection(mongoConfig.connectionString, {
-        dbName: undefined,
-    });
-    const ExportModel = (0, initExportModel_1.initExportModel)(connection);
-    const ProjectModel = (0, initProjectModel_1.initProjectModel)(connection);
-    const UserModel = (0, initUserModel_1.initUserModel)(connection);
-    const exportProvider = (0, mongoExportProvider_1.createMongoExportProvider)(ExportModel);
-    const projectProvider = (0, mongoProjectProvider_1.createMongoProjectProvider)(ProjectModel, ExportModel, adapter);
     return {
-        exportProvider,
-        projectProvider,
-        mongoConnection: connection,
+        exportProvider: mongoProviders?.exportProvider || prismaProviders?.exportProvider,
+        projectProviders: {
+            nosql: mongoProviders?.projectProvider,
+            sql: prismaProviders?.projectProvider,
+        },
+        exportCollectionProvider: mongoProviders?.exportCollectionProvider || prismaProviders?.exportCollectionProvider,
+        mongooseClient: mongoProviders?.mongooseClient,
+        prismaClient: prismaProviders?.prismaClient,
     };
 }

package/dist/providers/createMongooseProvider.d.ts

@@ -0,0 +1,8 @@
+import mongoose from 'mongoose';
+import { StorageAdapter, ProjectProvider, ExportProvider } from '../types';
+export declare function createMongooseProvider(connectionString: string, adapter: StorageAdapter): {
+    mongooseClient: mongoose.Connection;
+    exportProvider: ExportProvider;
+    projectProvider: ProjectProvider;
+    exportCollectionProvider: undefined;
+} | null;

package/dist/providers/createMongooseProvider.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMongooseProvider = createMongooseProvider;
+const mongoose_1 = __importDefault(require("mongoose"));
+const initProjectModel_1 = require("../mongoose_models/initProjectModel");
+const initExportModel_1 = require("../mongoose_models/initExportModel");
+const mongooseExportProvider_1 = require("./mongooseExportProvider");
+const mongooseProjectProvider_1 = require("./mongooseProjectProvider");
+function createMongooseProvider(connectionString, adapter) {
+    if (!connectionString) {
+        console.warn('Connection string is not provided. Mongoose client will not be initialized.');
+        return null;
+    }
+    const mongooseClient = mongoose_1.default.createConnection(connectionString, {
+        dbName: undefined,
+    });
+    const ExportModel = (0, initExportModel_1.initExportModel)(mongooseClient);
+    const ProjectModel = (0, initProjectModel_1.initProjectModel)(mongooseClient);
+    const exportProvider = (0, mongooseExportProvider_1.createMongooseExportProvider)(ExportModel);
+    const projectProvider = (0, mongooseProjectProvider_1.createMongooseProjectProvider)(ProjectModel, ExportModel, adapter);
+    // Mongoose does not have a direct equivalent for ExportCollectionProvider in the same way Prisma does.
+    // If a Mongoose-based ExportCollectionProvider is needed, it would be implemented here.
+    const exportCollectionProvider = undefined;
+    return {
+        mongooseClient,
+        exportProvider,
+        projectProvider,
+        exportCollectionProvider,
+    };
+}

package/dist/providers/createPrismaProvider.d.ts

@@ -0,0 +1,14 @@
+import { PrismaClient } from '@prisma/client';
+import { StorageAdapter, ProjectProvider, ExportProvider, ExportCollectionProvider } from '../types';
+export declare function createPrismaProvider(connectionString: string, adapter: StorageAdapter): {
+    prismaClient: PrismaClient<{
+        datasources: {
+            db: {
+                url: string;
+            };
+        };
+    }, never, import("@prisma/client/runtime/library").DefaultArgs>;
+    exportProvider: ExportProvider;
+    projectProvider: ProjectProvider;
+    exportCollectionProvider: ExportCollectionProvider;
+} | null;

package/dist/providers/createPrismaProvider.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPrismaProvider = createPrismaProvider;
+const client_1 = require("@prisma/client");
+const prismaExportProvider_1 = require("./prismaExportProvider");
+const prismaProjectProvider_1 = require("./prismaProjectProvider");
+const prismaExportCollectionProvider_1 = require("./prismaExportCollectionProvider");
+function createPrismaProvider(connectionString, adapter) {
+    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,
+            },
+        },
+    });
+    const exportProvider = (0, prismaExportProvider_1.createPrismaExportProvider)(prisma);
+    const projectProvider = (0, prismaProjectProvider_1.createPrismaProjectProvider)(prisma, adapter);
+    const exportCollectionProvider = (0, prismaExportCollectionProvider_1.createPrismaExportCollectionProvider)(prisma);
+    return {
+        prismaClient: prisma,
+        exportProvider,
+        projectProvider,
+        exportCollectionProvider,
+    };
+}

package/dist/providers/mongoProjectProvider.js

@@ -15,6 +15,7 @@ function createMongoProjectProvider(ProjectModel, ExportModel, adapter) {
         },
         async create(data) {
             const newProject = await ProjectModel.create({
+                dbType: data.dbType,
                 members: [
                     {
                         userId: data.members?.[0].userId,
@@ -25,7 +26,7 @@ function createMongoProjectProvider(ProjectModel, ExportModel, adapter) {
                 name: data.name,
                 description: data.description || '',
                 image: data.image || '',
-                rootFolders: data.rootFolders || [],
+                rootFolders: data.folders || [],
                 allowUpload: data.allowUpload ?? true,
                 allowSharing: data.allowSharing ?? false,
             });
@@ -74,6 +75,7 @@ function createMongoProjectProvider(ProjectModel, ExportModel, adapter) {
     function formatProject(doc) {
         return {
             id: doc._id.toString(),
+            dbType: doc.dbType,
             name: doc.name,
             image: doc.image,
             members: doc.members.map((m) => ({
@@ -84,7 +86,7 @@ function createMongoProjectProvider(ProjectModel, ExportModel, adapter) {
                 archived: m.archived ?? false
             })),
             description: doc.description,
-            rootFolders: doc.rootFolders || [],
+            folders: doc.rootFolders || [],
             settings: {
                 allowUpload: doc.allowUpload,
                 allowSharing: doc.allowSharing,
@@ -96,6 +98,7 @@ function createMongoProjectProvider(ProjectModel, ExportModel, adapter) {
         const archived = doc.members?.find((m) => m.userId?.toString() === userId)?.archived ?? false;
         return {
             id: doc._id.toString(),
+            dbType: doc.dbType,
             name: doc.name,
             image: doc.image,
             archived

package/dist/providers/mongooseExportProvider.d.ts

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

package/dist/providers/mongooseExportProvider.js

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

package/dist/providers/mongooseProjectProvider.d.ts

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

package/dist/providers/mongooseProjectProvider.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMongooseProjectProvider = createMongooseProjectProvider;
+function createMongooseProjectProvider(ProjectModel, ExportModel, adapter) {
+    return {
+        async getById(projectId, populateMembers = false) {
+            let query = ProjectModel.findById(projectId).populate('exports', ['_id', 'collectionName']);
+            if (populateMembers) {
+                // No longer populating 'members.userId' to avoid dependency on external User model
+            }
+            const project = await query;
+            if (!project)
+                throw new Error('Project not found');
+            return formatProject(project);
+        },
+        async create(data) {
+            const newProject = await ProjectModel.create({
+                dbType: data.dbType,
+                members: [
+                    {
+                        userId: data.members?.[0].userId,
+                        role: data.members?.[0].role,
+                        archived: false
+                    }
+                ],
+                name: data.name,
+                description: data.description || '',
+                image: data.image || '',
+                folders: data.folders || [],
+                allowUpload: data.allowUpload ?? true,
+                allowSharing: data.allowSharing ?? false,
+            });
+            return formatProject(newProject);
+        },
+        async update(projectId, updates) {
+            const updated = await ProjectModel.findByIdAndUpdate(projectId, updates, { new: true }).populate('exports', ['_id', 'collectionName']);
+            if (!updated)
+                throw new Error('Project not found');
+            return formatProject(updated);
+        },
+        async list(userId) {
+            const all = await ProjectModel.find(userId
+                ? { 'members': { $elemMatch: { userId } } }
+                : {});
+            return all.map(doc => formatProjectList(doc, userId));
+        },
+        async delete(projectId) {
+            try {
+                await ProjectModel.findByIdAndDelete(projectId);
+                await adapter.deleteProjectDirectory(projectId);
+                return { success: true };
+            }
+            catch (error) {
+                throw new Error('Project not found');
+            }
+        },
+        async archive(projectId, userId) {
+            await ProjectModel.updateOne({ _id: projectId, 'members.userId': userId }, { $set: { 'members.$.archived': true } });
+            return { success: true, projects: await this.list(userId) };
+        },
+        async unarchive(projectId, userId) {
+            await ProjectModel.updateOne({ _id: projectId, 'members.userId': userId }, { $set: { 'members.$.archived': false } });
+            return { success: true, projects: await this.list(userId) };
+        },
+        async getExport(projectId, exportId) {
+            const exportDoc = await ExportModel.findOne({ _id: exportId, project: projectId });
+            if (!exportDoc)
+                throw new Error('Export not found');
+            return exportDoc;
+        },
+        async addExportToProject(projectId, exportId) {
+            // En Mongoose, la relación ya está definida en el modelo Export.
+            // No es necesario actualizar el Project directamente.
+            // Si se necesita vincular un Export existente a un Project, se haría al crear o actualizar el Export.
+            // Por ejemplo, al crear un Export:
+            // ExportModel.create({ ..., projectId: projectId });
+            // O al actualizar un Export:
+            // ExportModel.findByIdAndUpdate(exportId, { projectId: projectId });
+            // Dado que el método original de Mongoose solo añade el ID, asumimos que el Export ya existe y tiene el projectId correcto.
+            // Si la lógica requiere añadir un Export existente a un Project, y el Export no tiene el projectId, se debería actualizar el Export.
+            // Por ahora, no se requiere ninguna acción aquí si la relación ya está establecida en el modelo Export.
+        }
+    };
+    function formatProject(doc) {
+        return {
+            id: doc._id.toString(),
+            dbType: doc.dbType,
+            name: doc.name,
+            image: doc.image,
+            members: doc.members.map((m) => ({
+                userId: m.userId,
+                role: m.role,
+                archived: m.archived ?? false
+            })),
+            description: doc.description,
+            folders: doc.rootFolders || [],
+            settings: {
+                allowUpload: doc.allowUpload,
+                allowSharing: doc.allowSharing,
+            },
+            exports: doc.exports || []
+        };
+    }
+    function formatProjectList(doc, userId) {
+        const archived = doc.members?.find((m) => m.userId?.toString() === userId)?.archived ?? false;
+        return {
+            id: doc._id.toString(),
+            dbType: doc.dbType,
+            name: doc.name,
+            image: doc.image,
+            archived
+        };
+    }
+}

package/dist/providers/prismaExportCollectionProvider.d.ts

@@ -0,0 +1,61 @@
+import { PrismaClient } from '@prisma/client';
+export declare function createPrismaExportCollectionProvider(prisma: PrismaClient): {
+    getById(id: string): Promise<({
+        entries: {
+            id: string;
+            exportCollectionId: string;
+            key: string;
+            value: string;
+        }[];
+    } & {
+        id: string;
+        name: string;
+        projectId: string;
+        createdAt: Date;
+        updatedAt: Date;
+    }) | 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;
+        projectId: string;
+        createdAt: Date;
+        updatedAt: Date;
+    }>;
+    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;
+        projectId: string;
+        createdAt: Date;
+        updatedAt: Date;
+    }>;
+    delete(id: string): Promise<{
+        success: boolean;
+    }>;
+};

package/dist/providers/prismaExportCollectionProvider.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPrismaExportCollectionProvider = createPrismaExportCollectionProvider;
+function createPrismaExportCollectionProvider(prisma) {
+    return {
+        async getById(id) {
+            return prisma.exportCollection.findUnique({
+                where: { id },
+                include: { entries: true },
+            });
+        },
+        async create(data) {
+            const { entries, ...rest } = data;
+            return prisma.exportCollection.create({
+                data: {
+                    ...rest,
+                    entries: {
+                        createMany: { data: entries },
+                    },
+                },
+                include: { entries: true },
+            });
+        },
+        async update(id, data) {
+            const { entries, ...rest } = data;
+            const updateData = { ...rest };
+            if (entries) {
+                // Eliminar entradas existentes y crear nuevas
+                await prisma.exportEntry.deleteMany({ where: { exportCollectionId: id } });
+                updateData.entries = {
+                    createMany: { data: entries },
+                };
+            }
+            return prisma.exportCollection.update({
+                where: { id },
+                data: updateData,
+                include: { entries: true },
+            });
+        },
+        async delete(id) {
+            await prisma.exportCollection.delete({ where: { id } });
+            return { success: true };
+        },
+    };
+}

package/dist/providers/prismaExportProvider.d.ts

@@ -0,0 +1,3 @@
+import { PrismaClient } from '@prisma/client';
+import { ExportProvider } from '../types';
+export declare function createPrismaExportProvider(prisma: PrismaClient): ExportProvider;

package/dist/providers/prismaExportProvider.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPrismaExportProvider = createPrismaExportProvider;
+function createPrismaExportProvider(prisma) {
+    return {
+        async getById(exportId) {
+            return await prisma.export.findUnique({ where: { id: exportId } });
+        },
+        async create(data) {
+            return await prisma.export.create({ data });
+        },
+    };
+}

package/dist/providers/prismaProjectProvider.d.ts

@@ -0,0 +1,3 @@
+import { PrismaClient } from '@prisma/client';
+import { ProjectProvider, StorageAdapter } from '../types';
+export declare function createPrismaProjectProvider(prisma: PrismaClient, adapter: StorageAdapter): ProjectProvider;

package/dist/providers/prismaProjectProvider.js

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPrismaProjectProvider = createPrismaProjectProvider;
+function createPrismaProjectProvider(prisma, adapter) {
+    return {
+        async getById(projectId, populateMembers = false) {
+            const project = await prisma.project.findUnique({
+                where: { id: projectId },
+                include: {
+                    exports: { select: { id: true, collectionName: true } },
+                    members: populateMembers ? true : false,
+                },
+            });
+            if (!project)
+                return null;
+            return formatProject(project);
+        },
+        async create(data) {
+            const newProject = await prisma.project.create({
+                data: {
+                    dbType: data.dbType,
+                    name: data.name,
+                    description: data.description || '',
+                    image: data.image || '',
+                    allowUpload: data.allowUpload ?? true,
+                    allowSharing: data.allowSharing ?? false,
+                    members: {
+                        create: data.members?.[0] ? {
+                            userId: data.members[0].userId,
+                            role: data.members[0].role,
+                            archived: false,
+                        } : undefined,
+                    },
+                },
+                include: {
+                    exports: { select: { id: true, collectionName: true } },
+                    members: true,
+                },
+            });
+            return formatProject(newProject);
+        },
+        async update(projectId, updates) {
+            const updated = await prisma.project.update({
+                where: { id: projectId },
+                data: {
+                    name: updates.name,
+                    description: updates.description,
+                    image: updates.image,
+                    allowUpload: updates.settings?.allowUpload,
+                    allowSharing: updates.settings?.allowSharing,
+                },
+                include: {
+                    exports: { select: { id: true, collectionName: true } },
+                    members: true,
+                },
+            });
+            if (!updated)
+                throw new Error('Project not found');
+            return formatProject(updated);
+        },
+        async list(userId) {
+            const all = await prisma.project.findMany({
+                where: userId ? { members: { some: { userId } } } : {},
+                include: {
+                    members: true,
+                },
+            });
+            return all.map(doc => formatProjectList(doc, userId));
+        },
+        async delete(projectId) {
+            try {
+                await prisma.project.delete({ where: { id: projectId } });
+                await adapter.deleteProjectDirectory(projectId);
+                return { success: true };
+            }
+            catch (error) {
+                throw new Error('Project not found');
+            }
+        },
+        async archive(projectId, userId) {
+            await prisma.member.updateMany({
+                where: { projectId, userId },
+                data: { archived: true },
+            });
+            return { success: true, projects: await this.list(userId) };
+        },
+        async unarchive(projectId, userId) {
+            await prisma.member.updateMany({
+                where: { projectId, userId },
+                data: { archived: false },
+            });
+            return { success: true, projects: await this.list(userId) };
+        },
+        async getExport(projectId, exportId) {
+            const exportDoc = await prisma.export.findFirst({
+                where: { id: exportId, projectId: projectId },
+            });
+            if (!exportDoc)
+                throw new Error('Export not found');
+            return exportDoc;
+        },
+        async addExportToProject(projectId, exportId) {
+            // En Prisma, la relación ya está definida en el modelo Export.
+            // No es necesario actualizar el Project directamente.
+            // Si se necesita vincular un Export existente a un Project, se haría al crear o actualizar el Export.
+            // Por ejemplo, al crear un Export:
+            // prisma.export.create({ data: { ..., projectId: projectId } });
+            // O al actualizar un Export:
+            // prisma.export.update({ where: { id: exportId }, data: { projectId: projectId } });
+            // Dado que el método original de Mongoose solo añade el ID, asumimos que el Export ya existe y tiene el projectId correcto.
+            // Si la lógica requiere añadir un Export existente a un Project, y el Export no tiene el projectId, se debería actualizar el Export.
+            // Por ahora, no se requiere ninguna acción aquí si la relación ya está establecida en el modelo Export.
+        },
+    };
+    function formatProject(doc) {
+        return {
+            id: doc.id,
+            dbType: doc.dbType,
+            name: doc.name,
+            image: doc.image,
+            members: doc.members?.map((m) => ({
+                userId: m.userId,
+                username: m.username, // Asumimos que el username y email se obtendrán de un servicio externo si es necesario
+                email: m.email,
+                role: m.role,
+                archived: m.archived ?? false
+            })) || [],
+            description: doc.description,
+            folders: doc.folders || [], // Prisma usa 'folders' en lugar de 'rootFolders'
+            settings: {
+                allowUpload: doc.allowUpload,
+                allowSharing: doc.allowSharing,
+            },
+            exports: doc.exports || []
+        };
+    }
+    function formatProjectList(doc, userId) {
+        const archived = doc.members?.find((m) => m.userId === userId)?.archived ?? false;
+        return {
+            id: doc.id,
+            dbType: doc.dbType,
+            name: doc.name,
+            image: doc.image,
+            archived
+        };
+    }
+}