streamby-core 0.13.0 → 0.15.0

package/dist/providers/mongoProjectProvider.js

@@ -1,16 +1,21 @@
 "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);
         },
         async create(data) {
             const newProject = await ProjectModel.create({
+                dbType: data.dbType,
                 members: [
                     {
                         userId: data.members?.[0].userId,
@@ -21,29 +26,23 @@ function createMongoProjectProvider(ProjectModel, adapter) {
                 name: data.name,
                 description: data.description || '',
                 image: data.image || '',
-                rootFolders: data.rootFolders || [],
+                rootFolders: 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 });
+            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, archived: { $ne: true } } } }
+                ? { 'members': { $elemMatch: { userId } } }
                 : {});
-            return all.map(formatProject);
-        },
-        async listArchived(userId) {
-            const all = await ProjectModel.find(userId
-                ? { 'members': { $elemMatch: { userId, archived: true } } }
-                : {});
-            return all.map(formatProject);
+            return all.map(doc => formatProjectList(doc, userId));
         },
         async delete(projectId) {
             try {
@@ -57,29 +56,52 @@ function createMongoProjectProvider(ProjectModel, adapter) {
         },
         async archive(projectId, userId) {
             await ProjectModel.updateOne({ _id: projectId, 'members.userId': userId }, { $set: { 'members.$.archived': true } });
-            return { success: true, projects: await this.list(userId), archivedProjects: await this.listArchived(userId) };
+            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), archivedProjects: await this.listArchived(userId) };
-        }
-    };
-}
-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,
-            archived: m.archived ?? false
-        })),
-        description: doc.description,
-        rootFolders: doc.rootFolders || [],
-        settings: {
-            allowUpload: doc.allowUpload,
-            allowSharing: doc.allowSharing,
+            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(),
+            dbType: doc.dbType,
+            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,
+            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;
+        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;
+    }>;
+};

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)
+                throw new Error('Project not found');
+            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
+        };
+    }
+}

package/dist/types/index.d.ts

@@ -25,6 +25,7 @@ export interface StorageAdapter {
 }
 export interface ProjectInfo {
     id: string;
+    dbType: DatabaseType;
     name: string;
     image?: string;
     members?: {
@@ -33,21 +34,32 @@ export interface ProjectInfo {
         archived?: boolean;
     }[];
     description?: string;
-    rootFolders?: FolderNode[];
+    folders?: FolderNode[];
+    exports?: {
+        id: string;
+        collectionName: string;
+    }[];
     settings?: {
         allowUpload?: boolean;
         allowSharing?: boolean;
     };
 }
+export interface ProjectListInfo {
+    id: string;
+    dbType: DatabaseType;
+    name: string;
+    image?: string;
+    archived: boolean;
+}
 export interface FolderNode {
     id: string;
     name: string;
     children?: FolderNode[];
 }
-export type DatabaseType = 'mongo';
+export type DatabaseType = 'sql' | 'nosql';
 export interface DatabaseCredential {
     dbType: DatabaseType;
-    connectionString: string;
+    connectionString?: string;
 }
 export interface StreamByConfig {
     storageProviders: {
@@ -56,7 +68,9 @@ export interface StreamByConfig {
     }[];
     authProvider: AuthProvider;
     databases?: DatabaseCredential[];
+    exportProvider?: ExportProvider;
     projectProvider?: ProjectProvider;
+    exportCollectionProvider?: ExportCollectionProvider;
     adapter?: StorageAdapter;
 }
 export interface AuthContext {
@@ -66,25 +80,40 @@ 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 | null>;
+    create(data: {
+        name: string;
+        description?: string;
+        collectionName: string;
+        projectId: string;
+    }): Promise<Export>;
+}
 export interface ProjectProvider {
+    getExport(projectId: string, exportId: string): Promise<any | null>;
     archive(projectId: string, userId: string): Promise<{
         success: boolean;
-        projects: ProjectInfo[];
-        archivedProjects: ProjectInfo[];
+        projects: ProjectListInfo[];
     }>;
     unarchive(projectId: string, userId: string): Promise<{
         success: boolean;
-        projects: ProjectInfo[];
-        archivedProjects: ProjectInfo[];
+        projects: ProjectListInfo[];
     }>;
-    list(userId?: string): Promise<ProjectInfo[]>;
-    listArchived(userId?: string): Promise<ProjectInfo[]>;
-    getById(projectId: string): Promise<ProjectInfo>;
+    list(userId?: string): Promise<ProjectListInfo[]>;
+    getById(projectId: string, populateMembers?: boolean): Promise<ProjectInfo>;
     delete(projectId: string): Promise<{
         success: boolean;
     }>;
-    update(projectId: string, updates: Partial<Omit<ProjectInfo, 'id' | 'rootFolders'>>): Promise<ProjectInfo>;
+    update(projectId: string, updates: Partial<Omit<ProjectInfo, 'id' | 'folders'>>): Promise<ProjectInfo>;
     create(data: {
+        dbType: DatabaseType;
         name: string;
         image?: string;
         members?: {
@@ -94,6 +123,34 @@ export interface ProjectProvider {
         description?: string;
         allowUpload?: boolean;
         allowSharing?: boolean;
-        rootFolders?: FolderNode[];
+        folders?: FolderNode[];
     }): Promise<ProjectInfo>;
+    addExportToProject(projectId: string, exportId: string): Promise<void>;
+}
+export interface ExportEntry {
+    id: string;
+    key: string;
+    value: string;
+    exportCollectionId: string;
+}
+export interface ExportCollectionProvider {
+    getById(id: string): Promise<any | null>;
+    create(data: {
+        projectId: string;
+        name: string;
+        entries: Array<{
+            key: string;
+            value: string;
+        }>;
+    }): Promise<any>;
+    update(id: string, data: {
+        name?: string;
+        entries?: Array<{
+            key: string;
+            value: string;
+        }>;
+    }): Promise<any>;
+    delete(id: string): Promise<{
+        success: boolean;
+    }>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "streamby-core",
-  "version": "0.13.0",
+  "version": "0.15.0",
   "description": "StreamBy middleware framework for media storage management",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -31,10 +31,12 @@
   "dependencies": {
     "@aws-sdk/client-s3": "^3.528.0",
     "@aws-sdk/s3-request-presigner": "^3.787.0",
+    "@prisma/client": "^6.12.0",
     "bcrypt": "^5.1.1",
     "dotenv": "^16.5.0",
     "express": "^4.0.0",
-    "mongoose": "^8.13.2"
+    "mongoose": "^8.13.2",
+    "prisma": "^6.12.0"
   },
   "devDependencies": {
     "@types/bcrypt": "^5.0.2",

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;
-}