streamby-core 0.15.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,72 +1,2 @@
-import mongoose from 'mongoose';
-import { StorageAdapter, DatabaseCredential } from '../types';
-import { PrismaClient } from '@prisma/client';
-export declare function createDatabaseProvider(databases: DatabaseCredential[], adapter: StorageAdapter): {
-    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;
-};
+import { StorageAdapter, DatabaseCredential, DatabaseProviders } from '../types';
+export declare function createDatabaseProvider(databases: DatabaseCredential[], adapter: StorageAdapter): DatabaseProviders;

package/dist/providers/createDatabaseProvider.js

@@ -1,58 +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 prismaExportProvider_1 = require("./prismaExportProvider");
-const prismaProjectProvider_1 = require("./prismaProjectProvider");
-const prismaExportCollectionProvider_1 = require("./prismaExportCollectionProvider");
+const createMongooseProvider_1 = require("./createMongooseProvider");
 function createDatabaseProvider(databases, adapter) {
-    let mongoConnection;
-    let prismaClient;
+    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.');
         }
-        mongoConnection = mongoose_1.default.createConnection(mongoConfig.connectionString, {
-            dbName: undefined,
-        });
+        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.');
         }
-        prismaClient = (0, createPrismaProvider_1.createPrismaProvider)(prismaConfig.connectionString) || undefined;
+        prismaProviders = (0, createPrismaProvider_1.createPrismaProvider)(prismaConfig.connectionString, adapter) || undefined;
     }
-    if (!mongoConnection && !prismaClient) {
+    if (!mongoProviders && !prismaProviders) {
         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 {
-        exportProvider: mongoExportProvider || prismaExportProvider,
+        exportProvider: mongoProviders?.exportProvider || prismaProviders?.exportProvider,
         projectProviders: {
-            nosql: mongoProjectProvider,
-            sql: prismaProjectProvider,
+            nosql: mongoProviders?.projectProvider,
+            sql: prismaProviders?.projectProvider,
         },
-        exportCollectionProvider: prismaExportCollectionProvider, // Solo Prisma tiene este por ahora
-        mongoConnection,
-        prismaClient,
+        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

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

package/dist/providers/createPrismaProvider.js

@@ -2,7 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createPrismaProvider = createPrismaProvider;
 const client_1 = require("@prisma/client");
-function createPrismaProvider(connectionString) {
+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;
@@ -14,5 +17,13 @@ function createPrismaProvider(connectionString) {
             },
         },
     });
-    return prisma;
+    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/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

@@ -10,9 +10,9 @@ export declare function createPrismaExportCollectionProvider(prisma: PrismaClien
     } & {
         id: string;
         name: string;
+        projectId: string;
         createdAt: Date;
         updatedAt: Date;
-        projectId: string;
     }) | null>;
     create(data: {
         projectId: string;
@@ -31,9 +31,9 @@ export declare function createPrismaExportCollectionProvider(prisma: PrismaClien
     } & {
         id: string;
         name: string;
+        projectId: string;
         createdAt: Date;
         updatedAt: Date;
-        projectId: string;
     }>;
     update(id: string, data: {
         name?: string;
@@ -51,9 +51,9 @@ export declare function createPrismaExportCollectionProvider(prisma: PrismaClien
     } & {
         id: string;
         name: string;
+        projectId: string;
         createdAt: Date;
         updatedAt: Date;
-        projectId: string;
     }>;
     delete(id: string): Promise<{
         success: boolean;

package/dist/providers/prismaProjectProvider.js

@@ -12,7 +12,7 @@ function createPrismaProjectProvider(prisma, adapter) {
                 },
             });
             if (!project)
-                throw new Error('Project not found');
+                return null;
             return formatProject(project);
         },
         async create(data) {

package/dist/types/index.d.ts

@@ -1,4 +1,5 @@
 import { Request } from 'express';
+import mongoose from 'mongoose';
 export interface S3Config {
     bucket: string;
     region: string;
@@ -107,7 +108,7 @@ export interface ProjectProvider {
         projects: ProjectListInfo[];
     }>;
     list(userId?: string): Promise<ProjectListInfo[]>;
-    getById(projectId: string, populateMembers?: boolean): Promise<ProjectInfo>;
+    getById(projectId: string, populateMembers?: boolean): Promise<ProjectInfo | null>;
     delete(projectId: string): Promise<{
         success: boolean;
     }>;
@@ -154,3 +155,13 @@ export interface ExportCollectionProvider {
         success: boolean;
     }>;
 }
+export interface DatabaseProviders {
+    exportProvider?: ExportProvider;
+    projectProviders: {
+        nosql?: ProjectProvider;
+        sql?: ProjectProvider;
+    };
+    exportCollectionProvider?: ExportCollectionProvider;
+    mongooseClient?: mongoose.Connection;
+    prismaClient?: any;
+}

package/package.json

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