streamby-core 0.12.3 → 0.14.0

package/dist/db/initExportModel.d.ts

@@ -0,0 +1,60 @@
+import mongoose from 'mongoose';
+export declare function initExportModel(connection: mongoose.Connection): mongoose.Model<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    name: string;
+    collectionName: string;
+    projectId: mongoose.Types.ObjectId;
+    description?: string | null | undefined;
+}, {}, {}, {}, mongoose.Document<unknown, {}, {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    name: string;
+    collectionName: string;
+    projectId: mongoose.Types.ObjectId;
+    description?: string | null | undefined;
+}> & {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    name: string;
+    collectionName: string;
+    projectId: mongoose.Types.ObjectId;
+    description?: string | null | undefined;
+} & {
+    _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;
+    collectionName: string;
+    projectId: mongoose.Types.ObjectId;
+    description?: string | null | undefined;
+}, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    name: string;
+    collectionName: string;
+    projectId: mongoose.Types.ObjectId;
+    description?: string | null | undefined;
+}>> & mongoose.FlatRecord<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    name: string;
+    collectionName: string;
+    projectId: mongoose.Types.ObjectId;
+    description?: string | null | undefined;
+}> & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}>>;

package/dist/db/initExportModel.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initExportModel = initExportModel;
+const mongoose_1 = __importDefault(require("mongoose"));
+function initExportModel(connection) {
+    const exportSchema = new mongoose_1.default.Schema({
+        name: { type: String, required: true },
+        description: { type: String },
+        collectionName: { type: String, required: true },
+        projectId: { type: mongoose_1.default.Schema.Types.ObjectId, ref: 'Project', required: true },
+    }, {
+        timestamps: true
+    });
+    return connection.model('Export', exportSchema);
+}

package/dist/db/initProjectModel.d.ts

@@ -398,13 +398,17 @@ export declare function initProjectModel(connection: mongoose.Connection): mongo
     members: mongoose.Types.DocumentArray<{
         userId: mongoose.Types.ObjectId;
         role: "viewer" | "editor" | "admin";
+        archived: boolean;
     }, mongoose.Types.Subdocument<mongoose.Types.ObjectId, any, {
         userId: mongoose.Types.ObjectId;
         role: "viewer" | "editor" | "admin";
+        archived: boolean;
     }> & {
         userId: mongoose.Types.ObjectId;
         role: "viewer" | "editor" | "admin";
+        archived: boolean;
     }>;
+    exports: mongoose.Types.ObjectId[];
     allowUpload: boolean;
     allowSharing: boolean;
     image?: string | null | undefined;
@@ -808,13 +812,17 @@ export declare function initProjectModel(connection: mongoose.Connection): mongo
     members: mongoose.Types.DocumentArray<{
         userId: mongoose.Types.ObjectId;
         role: "viewer" | "editor" | "admin";
+        archived: boolean;
     }, mongoose.Types.Subdocument<mongoose.Types.ObjectId, any, {
         userId: mongoose.Types.ObjectId;
         role: "viewer" | "editor" | "admin";
+        archived: boolean;
     }> & {
         userId: mongoose.Types.ObjectId;
         role: "viewer" | "editor" | "admin";
+        archived: boolean;
     }>;
+    exports: mongoose.Types.ObjectId[];
     allowUpload: boolean;
     allowSharing: boolean;
     image?: string | null | undefined;
@@ -1218,13 +1226,17 @@ export declare function initProjectModel(connection: mongoose.Connection): mongo
     members: mongoose.Types.DocumentArray<{
         userId: mongoose.Types.ObjectId;
         role: "viewer" | "editor" | "admin";
+        archived: boolean;
     }, mongoose.Types.Subdocument<mongoose.Types.ObjectId, any, {
         userId: mongoose.Types.ObjectId;
         role: "viewer" | "editor" | "admin";
+        archived: boolean;
     }> & {
         userId: mongoose.Types.ObjectId;
         role: "viewer" | "editor" | "admin";
+        archived: boolean;
     }>;
+    exports: mongoose.Types.ObjectId[];
     allowUpload: boolean;
     allowSharing: boolean;
     image?: string | null | undefined;
@@ -1634,13 +1646,17 @@ export declare function initProjectModel(connection: mongoose.Connection): mongo
     members: mongoose.Types.DocumentArray<{
         userId: mongoose.Types.ObjectId;
         role: "viewer" | "editor" | "admin";
+        archived: boolean;
     }, mongoose.Types.Subdocument<mongoose.Types.ObjectId, any, {
         userId: mongoose.Types.ObjectId;
         role: "viewer" | "editor" | "admin";
+        archived: boolean;
     }> & {
         userId: mongoose.Types.ObjectId;
         role: "viewer" | "editor" | "admin";
+        archived: boolean;
     }>;
+    exports: mongoose.Types.ObjectId[];
     allowUpload: boolean;
     allowSharing: boolean;
     image?: string | null | undefined;
@@ -2044,13 +2060,17 @@ export declare function initProjectModel(connection: mongoose.Connection): mongo
     members: mongoose.Types.DocumentArray<{
         userId: mongoose.Types.ObjectId;
         role: "viewer" | "editor" | "admin";
+        archived: boolean;
     }, mongoose.Types.Subdocument<mongoose.Types.ObjectId, any, {
         userId: mongoose.Types.ObjectId;
         role: "viewer" | "editor" | "admin";
+        archived: boolean;
     }> & {
         userId: mongoose.Types.ObjectId;
         role: "viewer" | "editor" | "admin";
+        archived: boolean;
     }>;
+    exports: mongoose.Types.ObjectId[];
     allowUpload: boolean;
     allowSharing: boolean;
     image?: string | null | undefined;
@@ -2454,13 +2474,17 @@ export declare function initProjectModel(connection: mongoose.Connection): mongo
     members: mongoose.Types.DocumentArray<{
         userId: mongoose.Types.ObjectId;
         role: "viewer" | "editor" | "admin";
+        archived: boolean;
     }, mongoose.Types.Subdocument<mongoose.Types.ObjectId, any, {
         userId: mongoose.Types.ObjectId;
         role: "viewer" | "editor" | "admin";
+        archived: boolean;
     }> & {
         userId: mongoose.Types.ObjectId;
         role: "viewer" | "editor" | "admin";
+        archived: boolean;
     }>;
+    exports: mongoose.Types.ObjectId[];
     allowUpload: boolean;
     allowSharing: boolean;
     image?: string | null | undefined;

package/dist/db/initProjectModel.js

@@ -11,6 +11,11 @@ function initProjectModel(connection) {
         name: String,
         children: [Object],
     }, { _id: false });
+    const memberSchema = new mongoose_1.default.Schema({
+        userId: { type: mongoose_1.default.Schema.Types.ObjectId, ref: 'User', 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({
         name: { type: String, required: true },
         description: { type: String },
@@ -18,10 +23,8 @@ function initProjectModel(connection) {
         rootFolders: [folderNodeSchema],
         allowUpload: { type: Boolean, default: true },
         allowSharing: { type: Boolean, default: false },
-        members: [{
-                userId: { type: mongoose_1.default.Schema.Types.ObjectId, ref: 'User', required: true },
-                role: { type: String, enum: ['viewer', 'editor', 'admin'], default: 'viewer' }
-            }]
+        members: [memberSchema],
+        exports: [{ type: mongoose_1.default.Schema.Types.ObjectId, ref: 'Export' }]
     }, {
         timestamps: true
     });

package/dist/db/initUserModel.d.ts

@@ -0,0 +1,48 @@
+import mongoose from 'mongoose';
+export declare function initUserModel(connection: mongoose.Connection): mongoose.Model<any, {}, {}, {}, any, any> | mongoose.Model<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    username: string;
+    email: string;
+}, {}, {}, {}, mongoose.Document<unknown, {}, {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    username: string;
+    email: string;
+}> & {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    username: string;
+    email: string;
+} & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}, mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, {}, {}, {}, {}, {
+    timestamps: true;
+}, {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    username: string;
+    email: string;
+}, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    username: string;
+    email: string;
+}>> & mongoose.FlatRecord<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    username: string;
+    email: string;
+}> & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}>>;

package/dist/db/initUserModel.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.initUserModel = initUserModel;
+const mongoose_1 = __importDefault(require("mongoose"));
+function initUserModel(connection) {
+    const userSchema = new mongoose_1.default.Schema({
+        username: { type: String, required: true, unique: true },
+        email: { type: String, required: true, unique: true },
+    }, {
+        timestamps: true
+    });
+    if (connection.models.User) {
+        return connection.models.User;
+    }
+    return connection.model('User', userSchema);
+}

package/dist/middleware/createRouter.js

@@ -15,13 +15,11 @@ 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 dbResult = config.projectProvider
+        ? { projectProvider: config.projectProvider, exportProvider: config.exportProvider, mongoConnection: undefined }
+        : (0, createDatabaseProvider_1.createDatabaseProvider)(config.databases, adapter);
+    const projectProvider = dbResult.projectProvider;
+    const exportProvider = dbResult.exportProvider;
     router.get('/auth', async (req, res) => {
         try {
             const auth = await config.authProvider(req);
@@ -80,21 +78,14 @@ function createStreamByRouter(config) {
             res.status(500).json({ error: 'Failed to list files', details: err });
         }
     });
-    router.get('/projects/:id', async (req, res) => {
+    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' });
-            }
-            if (!isProjectMember(project, auth.userId)) {
-                return res.status(403).json({ error: 'Unauthorized project access' });
-            }
-            res.json({ project });
+            const projects = await projectProvider.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) => {
@@ -115,6 +106,23 @@ 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 project = await projectProvider.getById(projectId);
+            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);
@@ -158,14 +166,95 @@ 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 project = await projectProvider.getById(projectId);
+            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/unarchive', async (req, res) => {
+        try {
+            const auth = await config.authProvider(req);
+            const projectId = req.params.id;
+            const project = await projectProvider.getById(projectId);
+            if (!project || !isProjectMember(project, auth.userId)) {
+                return res.status(403).json({ error: 'Unauthorized project access' });
+            }
+            const result = await projectProvider.unarchive(projectId, auth.userId);
+            res.status(200).json(result);
+        }
+        catch (err) {
+            res.status(500).json({ error: 'Failed to unarchive project', details: err.message });
+        }
+    });
+    router.get('/projects/:id/exports/:export_id', async (req, res) => {
+        try {
+            const auth = await config.authProvider(req);
+            const projectId = req.params.id;
+            const exportId = req.params.export_id;
+            const project = await projectProvider.getById(projectId);
+            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 project = await projectProvider.getById(projectId);
+            if (!project || !isProjectMember(project, auth.userId)) {
+                return res.status(403).json({ error: 'Unauthorized project access' });
+            }
+            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 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 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

@@ -6,6 +6,7 @@ export interface DatabaseCredential {
     connectionString: string;
 }
 export declare function createDatabaseProvider(databases: DatabaseCredential[], adapter: StorageAdapter): {
+    exportProvider: import("../types").ExportProvider;
     projectProvider: import("../types").ProjectProvider;
     mongoConnection: mongoose.Connection;
 };

package/dist/providers/createDatabaseProvider.js

@@ -6,20 +6,25 @@ 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");
 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.');
     }
-    // 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
+        dbName: undefined,
     });
+    const ExportModel = (0, initExportModel_1.initExportModel)(connection);
     const ProjectModel = (0, initProjectModel_1.initProjectModel)(connection);
-    const projectProvider = (0, mongoProjectProvider_1.createMongoProjectProvider)(ProjectModel, adapter);
+    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,
     };

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;

package/dist/providers/mongoProjectProvider.js

@@ -1,10 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createMongoProjectProvider = createMongoProjectProvider;
-function createMongoProjectProvider(ProjectModel, adapter) {
+function createMongoProjectProvider(ProjectModel, ExportModel, adapter) {
     return {
-        async getById(projectId) {
-            const project = await ProjectModel.findById(projectId);
+        async getById(projectId, populateMembers = false) {
+            let query = ProjectModel.findById(projectId).populate('exports', ['_id', 'collectionName']);
+            if (populateMembers) {
+                query = query.populate('members.userId');
+            }
+            const project = await query;
             if (!project)
                 throw new Error('Project not found');
             return formatProject(project);
@@ -15,6 +19,7 @@ function createMongoProjectProvider(ProjectModel, adapter) {
                     {
                         userId: data.members?.[0].userId,
                         role: data.members?.[0].role,
+                        archived: false
                     }
                 ],
                 name: data.name,
@@ -27,15 +32,16 @@ function createMongoProjectProvider(ProjectModel, adapter) {
             return formatProject(newProject);
         },
         async update(projectId, updates) {
-            const updated = await ProjectModel.findByIdAndUpdate(projectId, updates, { new: true });
+            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 query = userId ? { 'members.userId': userId } : {};
-            const all = await ProjectModel.find(query);
-            return all.map(formatProject);
+            const all = await ProjectModel.find(userId
+                ? { 'members': { $elemMatch: { userId } } }
+                : {});
+            return all.map(doc => formatProjectList(doc, userId));
         },
         async delete(projectId) {
             try {
@@ -46,23 +52,53 @@ function createMongoProjectProvider(ProjectModel, adapter) {
             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) {
+            await ProjectModel.findByIdAndUpdate(projectId, { $push: { exports: exportId } });
         }
     };
-}
-function formatProject(doc) {
-    return {
-        id: doc._id.toString(),
-        name: doc.name,
-        image: doc.image,
-        members: doc.members.map((m) => ({
-            userId: m.userId,
-            role: m.role,
-        })),
-        description: doc.description,
-        rootFolders: doc.rootFolders || [],
-        settings: {
-            allowUpload: doc.allowUpload,
-            allowSharing: doc.allowSharing,
-        }
-    };
+    function formatProject(doc) {
+        return {
+            id: doc._id.toString(),
+            name: doc.name,
+            image: doc.image,
+            members: doc.members.map((m) => ({
+                userId: m.userId?._id || m.userId,
+                username: m.userId?.username,
+                email: m.userId?.email,
+                role: m.role,
+                archived: m.archived ?? false
+            })),
+            description: doc.description,
+            rootFolders: 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(),
+            name: doc.name,
+            image: doc.image,
+            archived
+        };
+    }
 }

package/dist/types/index.d.ts

@@ -28,16 +28,27 @@ export interface ProjectInfo {
     name: string;
     image?: string;
     members?: {
-        userId: string;
         role: 'viewer' | 'editor' | 'admin';
+        userId: string;
+        archived?: boolean;
     }[];
     description?: string;
     rootFolders?: FolderNode[];
+    exports?: {
+        _id: string;
+        collectionName: string;
+    }[];
     settings?: {
         allowUpload?: boolean;
         allowSharing?: boolean;
     };
 }
+export interface ProjectListInfo {
+    id: string;
+    name: string;
+    image?: string;
+    archived: boolean;
+}
 export interface FolderNode {
     id: string;
     name: string;
@@ -55,6 +66,7 @@ export interface StreamByConfig {
     }[];
     authProvider: AuthProvider;
     databases?: DatabaseCredential[];
+    exportProvider?: ExportProvider;
     projectProvider?: ProjectProvider;
     adapter?: StorageAdapter;
 }
@@ -65,9 +77,34 @@ export interface AuthContext {
     role: 'viewer' | 'editor' | 'admin';
 }
 export type AuthProvider = (req: Request) => Promise<AuthContext>;
+export interface Export {
+    id: string;
+    collectionName: string;
+    projectId: string;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export interface ExportProvider {
+    getById(exportId: string): Promise<Export>;
+    create(data: {
+        name: string;
+        description?: string;
+        collectionName: string;
+        projectId: string;
+    }): Promise<Export>;
+}
 export interface ProjectProvider {
+    getExport(projectId: string, exportName: string): Promise<any[]>;
+    archive(projectId: string, userId: string): Promise<{
+        success: boolean;
+        projects: ProjectInfo[];
+    }>;
+    unarchive(projectId: string, userId: string): Promise<{
+        success: boolean;
+        projects: ProjectInfo[];
+    }>;
     list(userId?: string): Promise<ProjectInfo[]>;
-    getById(projectId: string): Promise<ProjectInfo>;
+    getById(projectId: string, populateMembers?: boolean): Promise<ProjectInfo>;
     delete(projectId: string): Promise<{
         success: boolean;
     }>;
@@ -84,4 +121,5 @@ export interface ProjectProvider {
         allowSharing?: boolean;
         rootFolders?: FolderNode[];
     }): Promise<ProjectInfo>;
+    addExportToProject(projectId: string, exportId: string): Promise<void>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "streamby-core",
-  "version": "0.12.3",
+  "version": "0.14.0",
   "description": "StreamBy middleware framework for media storage management",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/dist/dev/server.d.ts

@@ -1,4 +0,0 @@
-import { StorageAdapter, StreamByConfig } from "../types";
-export declare function createDevServer(config: StreamByConfig & {
-    adapter?: StorageAdapter;
-}): import("express-serve-static-core").Express;

package/dist/dev/server.js

@@ -1,14 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createDevServer = createDevServer;
-const express_1 = __importDefault(require("express"));
-const createRouter_1 = require("../middleware/createRouter");
-function createDevServer(config) {
-    const app = (0, express_1.default)();
-    app.use(express_1.default.json());
-    app.use((0, createRouter_1.createStreamByRouter)(config));
-    return app;
-}