streamby-core 0.14.0 → 0.15.0

package/dist/config.d.ts

@@ -0,0 +1,18 @@
+export declare const config: {
+    mongoUri: string;
+    s3: {
+        accessKeyId: string;
+        secretAccessKey: string;
+        region: string;
+        bucketName: string;
+    };
+    gcs: {
+        projectId: string;
+        keyFilename: string;
+        bucketName: string;
+    };
+    local: {
+        storagePath: string;
+    };
+    supabaseString: string;
+};

package/dist/config.js

@@ -1 +1,26 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.config = void 0;
+const dotenv_1 = __importDefault(require("dotenv"));
+dotenv_1.default.config();
+exports.config = {
+    mongoUri: process.env.MONGO_URI || '',
+    s3: {
+        accessKeyId: process.env.AWS_ACCESS_KEY_ID || '',
+        secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY || '',
+        region: process.env.AWS_REGION || 'us-east-1',
+        bucketName: process.env.AWS_BUCKET_NAME || 'streamby-dev',
+    },
+    gcs: {
+        projectId: process.env.GCS_PROJECT_ID || '',
+        keyFilename: process.env.GCS_KEY_FILENAME || '',
+        bucketName: process.env.GCS_BUCKET_NAME || 'streamby-dev',
+    },
+    local: {
+        storagePath: process.env.LOCAL_STORAGE_PATH || './uploads',
+    },
+    supabaseString: process.env.SUPABASE_STRING || '',
+};

package/dist/db/initExportModel.d.ts

@@ -15,7 +15,7 @@ export declare function initExportModel(connection: mongoose.Connection): mongoo
     collectionName: string;
     projectId: mongoose.Types.ObjectId;
     description?: string | null | undefined;
-}> & {
+}, {}> & {
     createdAt: NativeDate;
     updatedAt: NativeDate;
 } & {
@@ -45,7 +45,7 @@ export declare function initExportModel(connection: mongoose.Connection): mongoo
     collectionName: string;
     projectId: mongoose.Types.ObjectId;
     description?: string | null | undefined;
-}>> & mongoose.FlatRecord<{
+}>, {}> & mongoose.FlatRecord<{
     createdAt: NativeDate;
     updatedAt: NativeDate;
 } & {

package/dist/db/initProjectModel.d.ts

@@ -3,6 +3,22 @@ export declare function initProjectModel(connection: mongoose.Connection): mongo
     createdAt: NativeDate;
     updatedAt: NativeDate;
 } & {
+    dbType: string;
+    name: string;
+    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[];
     rootFolders: mongoose.Types.DocumentArray<{
         children: mongoose.Types.DocumentArray<{
             entries?: {} | null | undefined;
@@ -394,6 +410,15 @@ export declare function initProjectModel(connection: mongoose.Connection): mongo
         id?: string | null | undefined;
         name?: string | null | undefined;
     }>;
+    allowUpload: boolean;
+    allowSharing: boolean;
+    image?: string | null | undefined;
+    description?: string | null | undefined;
+}, {}, {}, {}, mongoose.Document<unknown, {}, {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    dbType: string;
     name: string;
     members: mongoose.Types.DocumentArray<{
         userId: mongoose.Types.ObjectId;
@@ -409,14 +434,6 @@ export declare function initProjectModel(connection: mongoose.Connection): mongo
         archived: boolean;
     }>;
     exports: mongoose.Types.ObjectId[];
-    allowUpload: boolean;
-    allowSharing: boolean;
-    image?: string | null | undefined;
-    description?: string | null | undefined;
-}, {}, {}, {}, mongoose.Document<unknown, {}, {
-    createdAt: NativeDate;
-    updatedAt: NativeDate;
-} & {
     rootFolders: mongoose.Types.DocumentArray<{
         children: mongoose.Types.DocumentArray<{
             entries?: {} | null | undefined;
@@ -808,6 +825,15 @@ export declare function initProjectModel(connection: mongoose.Connection): mongo
         id?: string | null | undefined;
         name?: string | null | undefined;
     }>;
+    allowUpload: boolean;
+    allowSharing: boolean;
+    image?: string | null | undefined;
+    description?: string | null | undefined;
+}, {}> & {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    dbType: string;
     name: string;
     members: mongoose.Types.DocumentArray<{
         userId: mongoose.Types.ObjectId;
@@ -823,14 +849,6 @@ export declare function initProjectModel(connection: mongoose.Connection): mongo
         archived: boolean;
     }>;
     exports: mongoose.Types.ObjectId[];
-    allowUpload: boolean;
-    allowSharing: boolean;
-    image?: string | null | undefined;
-    description?: string | null | undefined;
-}> & {
-    createdAt: NativeDate;
-    updatedAt: NativeDate;
-} & {
     rootFolders: mongoose.Types.DocumentArray<{
         children: mongoose.Types.DocumentArray<{
             entries?: {} | null | undefined;
@@ -1222,6 +1240,21 @@ export declare function initProjectModel(connection: mongoose.Connection): mongo
         id?: string | null | undefined;
         name?: string | null | undefined;
     }>;
+    allowUpload: boolean;
+    allowSharing: boolean;
+    image?: string | null | undefined;
+    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;
+} & {
+    dbType: string;
     name: string;
     members: mongoose.Types.DocumentArray<{
         userId: mongoose.Types.ObjectId;
@@ -1237,20 +1270,6 @@ export declare function initProjectModel(connection: mongoose.Connection): mongo
         archived: boolean;
     }>;
     exports: mongoose.Types.ObjectId[];
-    allowUpload: boolean;
-    allowSharing: boolean;
-    image?: string | null | undefined;
-    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;
-} & {
     rootFolders: mongoose.Types.DocumentArray<{
         children: mongoose.Types.DocumentArray<{
             entries?: {} | null | undefined;
@@ -1642,6 +1661,15 @@ export declare function initProjectModel(connection: mongoose.Connection): mongo
         id?: string | null | undefined;
         name?: string | null | undefined;
     }>;
+    allowUpload: boolean;
+    allowSharing: boolean;
+    image?: string | null | undefined;
+    description?: string | null | undefined;
+}, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    dbType: string;
     name: string;
     members: mongoose.Types.DocumentArray<{
         userId: mongoose.Types.ObjectId;
@@ -1657,14 +1685,6 @@ export declare function initProjectModel(connection: mongoose.Connection): mongo
         archived: boolean;
     }>;
     exports: mongoose.Types.ObjectId[];
-    allowUpload: boolean;
-    allowSharing: boolean;
-    image?: string | null | undefined;
-    description?: string | null | undefined;
-}, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
-    createdAt: NativeDate;
-    updatedAt: NativeDate;
-} & {
     rootFolders: mongoose.Types.DocumentArray<{
         children: mongoose.Types.DocumentArray<{
             entries?: {} | null | undefined;
@@ -2056,6 +2076,15 @@ export declare function initProjectModel(connection: mongoose.Connection): mongo
         id?: string | null | undefined;
         name?: string | null | undefined;
     }>;
+    allowUpload: boolean;
+    allowSharing: boolean;
+    image?: string | null | undefined;
+    description?: string | null | undefined;
+}>, {}> & mongoose.FlatRecord<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    dbType: string;
     name: string;
     members: mongoose.Types.DocumentArray<{
         userId: mongoose.Types.ObjectId;
@@ -2071,14 +2100,6 @@ export declare function initProjectModel(connection: mongoose.Connection): mongo
         archived: boolean;
     }>;
     exports: mongoose.Types.ObjectId[];
-    allowUpload: boolean;
-    allowSharing: boolean;
-    image?: string | null | undefined;
-    description?: string | null | undefined;
-}>> & mongoose.FlatRecord<{
-    createdAt: NativeDate;
-    updatedAt: NativeDate;
-} & {
     rootFolders: mongoose.Types.DocumentArray<{
         children: mongoose.Types.DocumentArray<{
             entries?: {} | null | undefined;
@@ -2470,21 +2491,6 @@ export declare function initProjectModel(connection: mongoose.Connection): mongo
         id?: string | null | undefined;
         name?: string | null | undefined;
     }>;
-    name: string;
-    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

@@ -17,6 +17,7 @@ function initProjectModel(connection) {
         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 },

package/dist/db/initUserModel.d.ts

@@ -11,7 +11,7 @@ export declare function initUserModel(connection: mongoose.Connection): mongoose
 } & {
     username: string;
     email: string;
-}> & {
+}, {}> & {
     createdAt: NativeDate;
     updatedAt: NativeDate;
 } & {
@@ -35,7 +35,7 @@ export declare function initUserModel(connection: mongoose.Connection): mongoose
 } & {
     username: string;
     email: string;
-}>> & mongoose.FlatRecord<{
+}>, {}> & mongoose.FlatRecord<{
     createdAt: NativeDate;
     updatedAt: NativeDate;
 } & {

package/dist/middleware/createRouter.js

@@ -15,11 +15,27 @@ function isProjectMember(project, userId) {
 function createStreamByRouter(config) {
     const router = express_1.default.Router();
     const adapter = config.adapter || (0, createStorageProvider_1.createStorageProvider)(config.storageProviders);
-    const 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;
+    const projectProviders = {};
+    let exportProvider;
+    let exportCollectionProvider;
+    if (config.databases) {
+        const db = (0, createDatabaseProvider_1.createDatabaseProvider)(config.databases, adapter);
+        projectProviders.nosql = db.projectProviders.nosql;
+        projectProviders.sql = db.projectProviders.sql;
+        exportProvider = db.exportProvider;
+        exportCollectionProvider = db.exportCollectionProvider;
+    }
+    else {
+        projectProviders.default = config.projectProvider;
+        exportProvider = config.exportProvider;
+        exportCollectionProvider = config.exportCollectionProvider;
+    }
+    if (!projectProviders.nosql && !projectProviders.sql) {
+        throw new Error('Project provider is not initialized. Please check your database configuration.');
+    }
+    if (!exportProvider) {
+        throw new Error('Export provider is not initialized. Please check your database configuration.');
+    }
     router.get('/auth', async (req, res) => {
         try {
             const auth = await config.authProvider(req);
@@ -29,6 +45,25 @@ function createStreamByRouter(config) {
             res.status(401).json({ logged: false });
         }
     });
+    router.get('/databases', async (req, res) => {
+        try {
+            const auth = await config.authProvider(req);
+            if (!auth) {
+                return res.status(401).json({ error: 'Unauthorized' });
+            }
+            const databases = [];
+            if (projectProviders.nosql) {
+                databases.push({ name: "NoSQL (Mongo)", value: "nosql" });
+            }
+            if (projectProviders.sql) {
+                databases.push({ name: "SQL (Prisma)", value: "sql" });
+            }
+            res.status(200).json({ databases });
+        }
+        catch (err) {
+            res.status(500).json({ error: 'Failed to get databases' });
+        }
+    });
     router.get('/upload-project-image-url/:id', async (req, res) => {
         try {
             const auth = await config.authProvider(req);
@@ -57,7 +92,11 @@ function createStreamByRouter(config) {
                 return res.status(400).json({ error: 'Missing projectId' });
             }
             await (0, file_1.deleteProjectImage)(adapter, projectId);
-            const updated = await projectProvider.update(projectId, { image: '' });
+            const provider = await getProjectProvider(projectId);
+            if (!provider) {
+                return res.status(404).json({ error: 'Project not found' });
+            }
+            const updated = await provider.update(projectId, { image: '' });
             res.status(201).json(updated);
         }
         catch (err) {
@@ -78,10 +117,58 @@ function createStreamByRouter(config) {
             res.status(500).json({ error: 'Failed to list files', details: err });
         }
     });
+    async function getProjectProvider(projectId, dbType) {
+        if (dbType) {
+            const specificProvider = projectProviders[dbType];
+            if (specificProvider) {
+                try {
+                    const project = await specificProvider.getById(projectId, true);
+                    if (project)
+                        return specificProvider;
+                }
+                catch (error) { /* ignore */ }
+            }
+        }
+        // Fallback to searching all providers if dbType is not provided or project not found in specific dbType
+        if (projectProviders.nosql) {
+            try {
+                const project = await projectProviders.nosql.getById(projectId, true);
+                if (project)
+                    return projectProviders.nosql;
+            }
+            catch (error) { /* ignore */ }
+        }
+        if (projectProviders.sql) {
+            try {
+                const project = await projectProviders.sql.getById(projectId, true);
+                if (project)
+                    return projectProviders.sql;
+            }
+            catch (error) { /* ignore */ }
+        }
+        if (projectProviders.default) {
+            try {
+                const project = await projectProviders.default.getById(projectId, true);
+                if (project)
+                    return projectProviders.default;
+            }
+            catch (error) { /* ignore */ }
+        }
+        return null;
+    }
     router.get('/projects', async (req, res) => {
         try {
             const auth = await config.authProvider(req);
-            const projects = await projectProvider.list(auth.userId);
+            const projects = [];
+            if (projectProviders.nosql) {
+                projects.push(...await projectProviders.nosql.list(auth.userId));
+            }
+            if (projectProviders.sql) {
+                projects.push(...await projectProviders.sql.list(auth.userId));
+            }
+            if (projectProviders.default) {
+                projects.push(...await projectProviders.default.list(auth.userId));
+            }
             res.json({ projects });
         }
         catch (err) {
@@ -94,8 +181,13 @@ function createStreamByRouter(config) {
             if (auth.role !== 'admin' && auth.role !== 'editor') {
                 return res.status(403).json({ error: 'Permission denied' });
             }
-            const { name, description } = req.body;
-            const newProject = await projectProvider.create({
+            const { name, description, dbType } = req.body;
+            const provider = dbType ? projectProviders[dbType] : projectProviders.default || projectProviders.nosql || projectProviders.sql;
+            if (!provider) {
+                return res.status(400).json({ error: 'Invalid dbType' });
+            }
+            const newProject = await provider.create({
+                dbType: dbType || 'nosql',
                 name,
                 description: description || '',
                 members: [{ userId: auth.userId, role: "admin" }]
@@ -110,7 +202,12 @@ function createStreamByRouter(config) {
         try {
             const auth = await config.authProvider(req);
             const projectId = req.params.id;
-            const project = await projectProvider.getById(projectId);
+            const dbType = req.query.dbType;
+            const projectProvider = await getProjectProvider(projectId, dbType);
+            if (!projectProvider) {
+                return res.status(404).json({ error: 'Project not found' });
+            }
+            const project = await projectProvider.getById(projectId, true);
             if (!project) {
                 return res.status(404).json({ error: 'Project not found' });
             }
@@ -131,7 +228,11 @@ function createStreamByRouter(config) {
             }
             const projectId = req.params.id;
             const updates = req.body;
-            const project = await projectProvider.getById(projectId);
+            const projectProvider = await getProjectProvider(projectId);
+            if (!projectProvider) {
+                return res.status(404).json({ error: 'Project not found' });
+            }
+            const project = await projectProvider.getById(projectId, true);
             if (!project) {
                 return res.status(404).json({ error: 'Project not found' });
             }
@@ -152,7 +253,11 @@ function createStreamByRouter(config) {
         try {
             const auth = await config.authProvider(req);
             const projectId = req.params.id;
-            const project = await projectProvider.getById(projectId);
+            const projectProvider = await getProjectProvider(projectId);
+            if (!projectProvider) {
+                return res.status(404).json({ error: 'Project not found' });
+            }
+            const project = await projectProvider.getById(projectId, true);
             if (!project) {
                 return res.status(404).json({ error: 'Project not found' });
             }
@@ -170,7 +275,11 @@ function createStreamByRouter(config) {
         try {
             const auth = await config.authProvider(req);
             const projectId = req.params.id;
-            const project = await projectProvider.getById(projectId);
+            const projectProvider = await getProjectProvider(projectId);
+            if (!projectProvider) {
+                return res.status(404).json({ error: 'Project not found' });
+            }
+            const project = await projectProvider.getById(projectId, true);
             if (!project || !isProjectMember(project, auth.userId)) {
                 return res.status(403).json({ error: 'Unauthorized project access' });
             }
@@ -185,7 +294,11 @@ function createStreamByRouter(config) {
         try {
             const auth = await config.authProvider(req);
             const projectId = req.params.id;
-            const project = await projectProvider.getById(projectId);
+            const projectProvider = await getProjectProvider(projectId);
+            if (!projectProvider) {
+                return res.status(404).json({ error: 'Project not found' });
+            }
+            const project = await projectProvider.getById(projectId, true);
             if (!project || !isProjectMember(project, auth.userId)) {
                 return res.status(403).json({ error: 'Unauthorized project access' });
             }
@@ -201,7 +314,11 @@ function createStreamByRouter(config) {
             const auth = await config.authProvider(req);
             const projectId = req.params.id;
             const exportId = req.params.export_id;
-            const project = await projectProvider.getById(projectId);
+            const projectProvider = await getProjectProvider(projectId);
+            if (!projectProvider) {
+                return res.status(404).json({ error: 'Project not found' });
+            }
+            const project = await projectProvider.getById(projectId, true);
             if (!project) {
                 return res.status(404).json({ error: 'Project not found' });
             }
@@ -223,7 +340,11 @@ function createStreamByRouter(config) {
             if (!name || !collectionName) {
                 return res.status(400).json({ error: 'Missing export name or collectionName' });
             }
-            const project = await projectProvider.getById(projectId);
+            const projectProvider = await getProjectProvider(projectId);
+            if (!projectProvider) {
+                return res.status(404).json({ error: 'Project not found' });
+            }
+            const project = await projectProvider.getById(projectId, true);
             if (!project || !isProjectMember(project, auth.userId)) {
                 return res.status(403).json({ error: 'Unauthorized project access' });
             }
@@ -244,6 +365,10 @@ function createStreamByRouter(config) {
         try {
             const auth = await config.authProvider(req);
             const projectId = req.params.id;
+            const projectProvider = await getProjectProvider(projectId);
+            if (!projectProvider) {
+                return res.status(404).json({ error: 'Project not found' });
+            }
             const project = await projectProvider.getById(projectId, true);
             if (!project) {
                 return res.status(404).json({ error: 'Project not found' });

package/dist/models/ExportCollection.d.ts

@@ -13,7 +13,7 @@ export declare function initExportCollectionModel(connection: mongoose.Connectio
     name: string;
     entries: mongoose.Types.DocumentArray<{}, mongoose.Types.Subdocument<unknown, any, {}>>;
     projectId: mongoose.Types.ObjectId;
-}> & {
+}, {}> & {
     createdAt: NativeDate;
     updatedAt: NativeDate;
 } & {
@@ -40,7 +40,7 @@ export declare function initExportCollectionModel(connection: mongoose.Connectio
     name: string;
     entries: mongoose.Types.DocumentArray<{}, mongoose.Types.Subdocument<unknown, any, {}>>;
     projectId: mongoose.Types.ObjectId;
-}>> & mongoose.FlatRecord<{
+}>, {}> & mongoose.FlatRecord<{
     createdAt: NativeDate;
     updatedAt: NativeDate;
 } & {

package/dist/providers/createDatabaseProvider.d.ts

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

package/dist/providers/createDatabaseProvider.js

@@ -10,22 +10,49 @@ const initUserModel_1 = require("../db/initUserModel");
 const mongoExportProvider_1 = require("./mongoExportProvider");
 const mongoProjectProvider_1 = require("./mongoProjectProvider");
 const initExportModel_1 = require("../db/initExportModel");
+const createPrismaProvider_1 = require("./createPrismaProvider");
+const prismaExportProvider_1 = require("./prismaExportProvider");
+const prismaProjectProvider_1 = require("./prismaProjectProvider");
+const prismaExportCollectionProvider_1 = require("./prismaExportCollectionProvider");
 function createDatabaseProvider(databases, adapter) {
-    const mongoConfig = databases.find((db) => db.dbType === 'mongo');
-    if (!mongoConfig) {
-        throw new Error('No MongoDB configuration provided. Mongo is currently required.');
+    let mongoConnection;
+    let prismaClient;
+    const mongoConfig = databases.find((db) => db.dbType === 'nosql');
+    if (mongoConfig) {
+        if (!mongoConfig.connectionString) {
+            throw new Error('MongoDB connection string is required for mongo dbType.');
+        }
+        mongoConnection = mongoose_1.default.createConnection(mongoConfig.connectionString, {
+            dbName: undefined,
+        });
     }
-    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);
+    const prismaConfig = databases.find((db) => db.dbType === 'sql');
+    if (prismaConfig) {
+        if (!prismaConfig.connectionString) {
+            throw new Error('Prisma connection string is required for prisma dbType.');
+        }
+        prismaClient = (0, createPrismaProvider_1.createPrismaProvider)(prismaConfig.connectionString) || undefined;
+    }
+    if (!mongoConnection && !prismaClient) {
+        throw new Error('At least one database configuration (mongo or prisma) is required.');
+    }
+    // If mongoConnection is not defined, we can't create mongo-based providers
+    const ExportModel = mongoConnection ? (0, initExportModel_1.initExportModel)(mongoConnection) : undefined;
+    const ProjectModel = mongoConnection ? (0, initProjectModel_1.initProjectModel)(mongoConnection) : undefined;
+    const UserModel = mongoConnection ? (0, initUserModel_1.initUserModel)(mongoConnection) : undefined;
+    const mongoExportProvider = ExportModel ? (0, mongoExportProvider_1.createMongoExportProvider)(ExportModel) : undefined;
+    const mongoProjectProvider = ProjectModel && ExportModel ? (0, mongoProjectProvider_1.createMongoProjectProvider)(ProjectModel, ExportModel, adapter) : undefined;
+    const prismaExportProvider = prismaClient ? (0, prismaExportProvider_1.createPrismaExportProvider)(prismaClient) : undefined;
+    const prismaProjectProvider = prismaClient ? (0, prismaProjectProvider_1.createPrismaProjectProvider)(prismaClient, adapter) : undefined;
+    const prismaExportCollectionProvider = prismaClient ? (0, prismaExportCollectionProvider_1.createPrismaExportCollectionProvider)(prismaClient) : undefined;
     return {
-        exportProvider,
-        projectProvider,
-        mongoConnection: connection,
+        exportProvider: mongoExportProvider || prismaExportProvider,
+        projectProviders: {
+            nosql: mongoProjectProvider,
+            sql: prismaProjectProvider,
+        },
+        exportCollectionProvider: prismaExportCollectionProvider, // Solo Prisma tiene este por ahora
+        mongoConnection,
+        prismaClient,
     };
 }

package/dist/providers/createPrismaProvider.d.ts

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

package/dist/providers/createPrismaProvider.js

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

package/dist/providers/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/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,9 +34,9 @@ export interface ProjectInfo {
         archived?: boolean;
     }[];
     description?: string;
-    rootFolders?: FolderNode[];
+    folders?: FolderNode[];
     exports?: {
-        _id: string;
+        id: string;
         collectionName: string;
     }[];
     settings?: {
@@ -45,6 +46,7 @@ export interface ProjectInfo {
 }
 export interface ProjectListInfo {
     id: string;
+    dbType: DatabaseType;
     name: string;
     image?: string;
     archived: boolean;
@@ -54,10 +56,10 @@ export interface FolderNode {
     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: {
@@ -68,6 +70,7 @@ export interface StreamByConfig {
     databases?: DatabaseCredential[];
     exportProvider?: ExportProvider;
     projectProvider?: ProjectProvider;
+    exportCollectionProvider?: ExportCollectionProvider;
     adapter?: StorageAdapter;
 }
 export interface AuthContext {
@@ -85,7 +88,7 @@ export interface Export {
     updatedAt: Date;
 }
 export interface ExportProvider {
-    getById(exportId: string): Promise<Export>;
+    getById(exportId: string): Promise<Export | null>;
     create(data: {
         name: string;
         description?: string;
@@ -94,22 +97,23 @@ export interface ExportProvider {
     }): Promise<Export>;
 }
 export interface ProjectProvider {
-    getExport(projectId: string, exportName: string): Promise<any[]>;
+    getExport(projectId: string, exportId: string): Promise<any | null>;
     archive(projectId: string, userId: string): Promise<{
         success: boolean;
-        projects: ProjectInfo[];
+        projects: ProjectListInfo[];
     }>;
     unarchive(projectId: string, userId: string): Promise<{
         success: boolean;
-        projects: ProjectInfo[];
+        projects: ProjectListInfo[];
     }>;
-    list(userId?: 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?: {
@@ -119,7 +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.14.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",