streamby-core 0.17.0 → 0.19.0

package/dist/mongoose_models/initProjectModel.js

@@ -1,34 +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.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: String, 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,2 +0,0 @@
-import { StorageAdapter, DatabaseCredential, DatabaseProviders } from '../types';
-export declare function createDatabaseProvider(databases: DatabaseCredential[], adapter: StorageAdapter): DatabaseProviders;

package/dist/providers/createDatabaseProvider.js

@@ -1,36 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createDatabaseProvider = createDatabaseProvider;
-const createPrismaProvider_1 = require("./createPrismaProvider");
-const createMongooseProvider_1 = require("./createMongooseProvider");
-function createDatabaseProvider(databases, adapter) {
-    let mongoProviders;
-    let prismaProviders;
-    const mongoConfig = databases.find((db) => db.dbType === 'nosql');
-    if (mongoConfig) {
-        if (!mongoConfig.connectionString) {
-            throw new Error('MongoDB connection string is required for mongo dbType.');
-        }
-        mongoProviders = (0, createMongooseProvider_1.createMongooseProvider)(mongoConfig.connectionString, adapter) || undefined;
-    }
-    const prismaConfig = databases.find((db) => db.dbType === 'sql');
-    if (prismaConfig) {
-        if (!prismaConfig.connectionString) {
-            throw new Error('Prisma connection string is required for prisma dbType.');
-        }
-        prismaProviders = (0, createPrismaProvider_1.createPrismaProvider)(prismaConfig.connectionString, adapter) || undefined;
-    }
-    if (!mongoProviders && !prismaProviders) {
-        throw new Error('At least one database configuration (mongo or prisma) is required.');
-    }
-    return {
-        exportProvider: mongoProviders?.exportProvider || prismaProviders?.exportProvider,
-        projectProviders: {
-            nosql: mongoProviders?.projectProvider,
-            sql: prismaProviders?.projectProvider,
-        },
-        exportCollectionProvider: mongoProviders?.exportCollectionProvider || prismaProviders?.exportCollectionProvider,
-        mongooseClient: mongoProviders?.mongooseClient,
-        prismaClient: prismaProviders?.prismaClient,
-    };
-}

package/dist/providers/createMongooseProvider.d.ts

@@ -1,8 +0,0 @@
-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

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

package/dist/providers/createPrismaProvider.js

@@ -1,29 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createPrismaProvider = createPrismaProvider;
-const client_1 = require("@prisma/client");
-const prismaExportProvider_1 = require("./prismaExportProvider");
-const prismaProjectProvider_1 = require("./prismaProjectProvider");
-const prismaExportCollectionProvider_1 = require("./prismaExportCollectionProvider");
-function createPrismaProvider(connectionString, adapter) {
-    if (!connectionString) {
-        console.warn('Connection string is not provided. Prisma client will not be initialized.');
-        return null;
-    }
-    const prisma = new client_1.PrismaClient({
-        datasources: {
-            db: {
-                url: connectionString,
-            },
-        },
-    });
-    const exportProvider = (0, prismaExportProvider_1.createPrismaExportProvider)(prisma);
-    const projectProvider = (0, prismaProjectProvider_1.createPrismaProjectProvider)(prisma, adapter);
-    const exportCollectionProvider = (0, prismaExportCollectionProvider_1.createPrismaExportCollectionProvider)(prisma);
-    return {
-        prismaClient: prisma,
-        exportProvider,
-        projectProvider,
-        exportCollectionProvider,
-    };
-}

package/dist/providers/mongoExportProvider.d.ts

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

package/dist/providers/mongoExportProvider.js

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

package/dist/providers/mongoProjectProvider.d.ts

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

package/dist/providers/mongoProjectProvider.js

@@ -1,107 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createMongoProjectProvider = createMongoProjectProvider;
-function createMongoProjectProvider(ProjectModel, ExportModel, adapter) {
-    return {
-        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,
-                        role: data.members?.[0].role,
-                        archived: false
-                    }
-                ],
-                name: data.name,
-                description: data.description || '',
-                image: data.image || '',
-                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 }).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) {
-            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/mongooseExportProvider.d.ts

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

package/dist/providers/mongooseExportProvider.js

@@ -1,13 +0,0 @@
-"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

@@ -1,3 +0,0 @@
-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

@@ -1,114 +0,0 @@
-"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

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

package/dist/providers/prismaExportCollectionProvider.js

@@ -1,45 +0,0 @@
-"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

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

package/dist/providers/prismaExportProvider.js

@@ -1,13 +0,0 @@
-"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

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