streamby-core 0.20.2 → 0.21.1

package/dist/adapters/database/connectionManager.d.ts

@@ -2,5 +2,9 @@ import { Pool } from 'pg';
 import { MongoClient } from 'mongodb';
 import { DatabaseCredential } from '../../types';
 export declare const initConnections: (configs: DatabaseCredential[]) => Promise<void>;
-export declare const getConnection: (id: string) => Pool | MongoClient;
+export declare const getConnection: (id: string) => {
+    id: string;
+    type: "sql" | "nosql";
+    client: Pool | MongoClient;
+};
 export declare const getConnectedIds: () => string[];

package/dist/adapters/database/connectionManager.js

@@ -3,8 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getConnectedIds = exports.getConnection = exports.initConnections = void 0;
 const pg_1 = require("pg");
 const mongodb_1 = require("mongodb");
-const clients = {};
-const connectedIds = [];
+const nosql_1 = require("./nosql");
+const connectedClients = [];
 const initConnections = async (configs) => {
     for (const config of configs) {
         if (!config.connectionString) {
@@ -15,16 +15,16 @@ const initConnections = async (configs) => {
             if (config.type === 'sql') {
                 const pool = new pg_1.Pool({ connectionString: config.connectionString });
                 await pool.connect();
-                clients[config.id] = pool;
-                connectedIds.push(config.id);
+                connectedClients.push({ id: config.id, type: 'sql', client: pool });
                 console.log(`🟢 PostgreSQL connection established for ID: ${config.id}`);
+                await ensureTablesExist(pool);
             }
             else if (config.type === 'nosql') {
                 const client = new mongodb_1.MongoClient(config.connectionString);
                 await client.connect();
-                clients[config.id] = client;
-                connectedIds.push(config.id);
+                connectedClients.push({ id: config.id, type: 'nosql', client: client });
                 console.log(`🟢 MongoDB connection established for ID: ${config.id}`);
+                await (0, nosql_1.ensureCollectionsExist)(client);
             }
         }
         catch (error) {
@@ -34,14 +34,70 @@ const initConnections = async (configs) => {
 };
 exports.initConnections = initConnections;
 const getConnection = (id) => {
-    const client = clients[id];
-    if (!client) {
+    const clientEntry = connectedClients.find(c => c.id === id);
+    if (!clientEntry) {
         throw new Error(`Connection with id ${id} not found.`);
     }
-    return client;
+    return clientEntry;
 };
 exports.getConnection = getConnection;
+const ensureTablesExist = async (pool) => {
+    try {
+        await pool.query(`
+      CREATE EXTENSION IF NOT EXISTS "uuid-ossp";
+      CREATE TABLE IF NOT EXISTS projects (
+        id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+        name VARCHAR(255) NOT NULL,
+        description TEXT,
+        "createdAt" TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
+        "updatedAt" TIMESTAMP WITH TIME ZONE DEFAULT NOW()
+      );
+    `);
+        console.log('✅ "projects" table ensured to exist.');
+        // Ensure dbType column exists and is correctly configured
+        await pool.query(`
+      ALTER TABLE projects ADD COLUMN IF NOT EXISTS "dbType" VARCHAR(50);
+    `);
+        await pool.query(`
+      UPDATE projects SET "dbType" = 'nosql' WHERE "dbType" IS NULL;
+    `);
+        await pool.query(`
+      ALTER TABLE projects ALTER COLUMN "dbType" SET NOT NULL;
+    `);
+        await pool.query(`
+      ALTER TABLE projects ALTER COLUMN "dbType" SET DEFAULT 'nosql';
+    `);
+        await pool.query(`
+      CREATE TABLE IF NOT EXISTS exports (
+        id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+        "projectId" UUID NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+        status VARCHAR(50) NOT NULL DEFAULT 'pending',
+        "filePath" TEXT,
+        "createdAt" TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
+        "updatedAt" TIMESTAMP WITH TIME ZONE DEFAULT NOW()
+      );
+    `);
+        console.log('✅ "exports" table ensured to exist.');
+        await pool.query(`
+      CREATE TABLE IF NOT EXISTS project_members (
+        id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+        "projectId" UUID NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+        "userId" VARCHAR(255) NOT NULL,
+        archived BOOLEAN NOT NULL DEFAULT FALSE,
+        "archivedBy" VARCHAR(255),
+        "archivedAt" TIMESTAMP WITH TIME ZONE,
+        "createdAt" TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
+        "updatedAt" TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
+        UNIQUE ("projectId", "userId")
+      );
+    `);
+        console.log('✅ "project_members" table ensured to exist.');
+    }
+    catch (error) {
+        console.error('❌ Error ensuring tables exist:', error);
+    }
+};
 const getConnectedIds = () => {
-    return connectedIds;
+    return connectedClients.map(c => c.id);
 };
 exports.getConnectedIds = getConnectedIds;

package/dist/adapters/database/nosql.d.ts

@@ -1,4 +1,5 @@
 import { MongoClient, Document } from 'mongodb';
+export declare const ensureCollectionsExist: (client: MongoClient) => Promise<void>;
 export declare const nosqlAdapter: {
     find: (connection: MongoClient, tableName: string, filter: any) => Promise<Document[]>;
     findOne: (connection: MongoClient, tableName: string, filter: any) => Promise<Document | null>;

package/dist/adapters/database/nosql.js

@@ -1,7 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.nosqlAdapter = void 0;
+exports.nosqlAdapter = exports.ensureCollectionsExist = void 0;
 const mongodb_1 = require("mongodb");
+const ensureCollectionsExist = async (client) => {
+    const db = client.db();
+    // Ensure 'projects' collection exists and define its schema implicitly
+    // Schema: { _id: ObjectId, name: string, description: string, dbType: string, createdAt: Date, updatedAt: Date, members: [{ userId: string, archived: boolean }] }
+    const projectsCollection = db.collection('projects');
+    await projectsCollection.findOne({}); // Attempt to find one to ensure collection is created if it doesn't exist
+    console.log('✅ "projects" collection ensured to exist.');
+    // Ensure 'exports' collection exists and define its schema implicitly
+    // Schema: { _id: ObjectId, projectId: ObjectId, status: string, filePath: string, createdAt: Date, updatedAt: Date }
+    const exportsCollection = db.collection('exports');
+    await exportsCollection.findOne({}); // Attempt to find one to ensure collection is created if it doesn't exist
+    console.log('✅ "exports" collection ensured to exist.');
+};
+exports.ensureCollectionsExist = ensureCollectionsExist;
 exports.nosqlAdapter = {
     find: async (connection, tableName, filter) => {
         const db = connection.db();

package/dist/adapters/database/sql.js

@@ -5,8 +5,12 @@ exports.sqlAdapter = {
     find: async (connection, tableName, filter) => {
         const keys = Object.keys(filter);
         const values = Object.values(filter);
-        const where = keys.map((key, i) => `"${key}" = $${i + 1}`).join(' AND ');
-        const result = await connection.query(`SELECT * FROM "${tableName}" WHERE ${where}`, values);
+        let query = `SELECT * FROM "${tableName}"`;
+        if (keys.length > 0) {
+            const where = keys.map((key, i) => `"${key}" = $${i + 1}`).join(' AND ');
+            query += ` WHERE ${where}`;
+        }
+        const result = await connection.query(query, values);
         return result.rows;
     },
     findOne: async (connection, tableName, filter) => {
@@ -17,7 +21,7 @@ exports.sqlAdapter = {
         return result.rows[0] || null;
     },
     create: async (connection, tableName, data) => {
-        const keys = Object.keys(data).join(', ');
+        const keys = Object.keys(data).map(key => `"${key}"`).join(', ');
         const values = Object.values(data);
         const placeholders = values.map((_, i) => `$${i + 1}`).join(', ');
         const result = await connection.query(`INSERT INTO "${tableName}" (${keys}) VALUES (${placeholders}) RETURNING *`, values);

package/dist/middleware/createRouter.js

@@ -18,28 +18,32 @@ function createStreamByRouter(config) {
     (0, connectionManager_1.initConnections)(config.databases || []);
     const adapter = config.adapter || (0, storage_1.createStorageProvider)(config.storageProviders);
     if (config.databases) {
-        for (const db of config.databases) {
-            if (db.type === 'sql') {
-                (0, manager_1.registerModel)('Project', [db.id], 'projects');
-                (0, manager_1.registerModel)('Export', [db.id], 'exports');
-            }
-        }
+        const allDbIds = config.databases.map(db => db.id);
+        (0, manager_1.registerModel)('projects', allDbIds, 'projects');
+        (0, manager_1.registerModel)('exports', allDbIds, 'exports');
     }
-    const Project = (0, manager_1.getModel)('Project');
-    const Export = (0, manager_1.getModel)('Export');
+    const Project = (0, manager_1.getModel)('projects');
+    const Export = (0, manager_1.getModel)('exports');
     router.get('/auth', async (req, res) => {
         try {
             const auth = await config.authProvider(req);
-            res.status(200).json({ logged: true, ...auth });
+            if (!auth ||
+                !auth.userId ||
+                !auth.role) {
+                throw new Error('Invalid or missing authentication context');
+            }
+            return res.status(200).json({ logged: true, ...auth });
         }
         catch (err) {
-            res.status(401).json({ logged: false });
+            return res.status(401).json({ logged: false });
         }
     });
     router.get('/databases', async (req, res) => {
         try {
             const auth = await config.authProvider(req);
-            if (!auth) {
+            if (!auth ||
+                !auth.userId ||
+                !auth.role) {
                 return res.status(401).json({ error: 'Unauthorized' });
             }
             const connectedDbIds = (0, connectionManager_1.getConnectedIds)();
@@ -55,6 +59,11 @@ function createStreamByRouter(config) {
     router.get('/upload-project-image-url/:id', async (req, res) => {
         try {
             const auth = await config.authProvider(req);
+            if (!auth ||
+                !auth.userId ||
+                !auth.role) {
+                return res.status(401).json({ error: 'Unauthorized' });
+            }
             if (auth.role !== 'admin' && auth.role !== 'editor') {
                 return res.status(403).json({ error: 'Permission denied' });
             }
@@ -72,6 +81,11 @@ function createStreamByRouter(config) {
     router.delete('/delete-project-image-url/:id', async (req, res) => {
         try {
             const auth = await config.authProvider(req);
+            if (!auth ||
+                !auth.userId ||
+                !auth.role) {
+                return res.status(401).json({ error: 'Unauthorized' });
+            }
             if (auth.role !== 'admin' && auth.role !== 'editor') {
                 return res.status(403).json({ error: 'Permission denied' });
             }
@@ -90,6 +104,11 @@ function createStreamByRouter(config) {
     router.get('/files', async (req, res) => {
         try {
             const auth = await config.authProvider(req);
+            if (!auth ||
+                !auth.userId ||
+                !auth.role) {
+                return res.status(401).json({ error: 'Unauthorized' });
+            }
             const projectId = (req.query.projectId || req.headers['x-project-id']);
             if (!projectId) {
                 return res.status(403).json({ error: 'Unauthorized or missing projectId' });
@@ -104,8 +123,26 @@ function createStreamByRouter(config) {
     router.get('/projects', async (req, res) => {
         try {
             const auth = await config.authProvider(req);
-            const archived = req.query.archived ? String(req.query.archived).toLowerCase() === 'true' : undefined;
-            const projects = (await Project.find({ members: { $elemMatch: { userId: auth.userId } }, archived })).map(project => {
+            if (!auth ||
+                !auth.userId ||
+                !auth.role) {
+                return res.status(401).json({ error: 'Unauthorized' });
+            }
+            const archivedQuery = req.query.archived;
+            const filterArchived = archivedQuery !== undefined ? String(archivedQuery).toLowerCase() === 'true' : undefined;
+            const allProjects = await Project.find({}); // Fetch all projects
+            const projects = allProjects
+                .filter(project => {
+                const isMember = project.members?.some((m) => m.userId?.toString() === auth.userId?.toString());
+                if (!isMember)
+                    return false;
+                if (filterArchived !== undefined) {
+                    const currentUserMember = project.members?.find((member) => member.userId === auth.userId);
+                    return currentUserMember ? (currentUserMember.archived || false) === filterArchived : false;
+                }
+                return true;
+            })
+                .map(project => {
                 const currentUserMember = project.members?.find((member) => member.userId === auth.userId);
                 return {
                     id: project._id || project.id,
@@ -118,12 +155,18 @@ function createStreamByRouter(config) {
             res.json({ projects });
         }
         catch (err) {
+            console.error('Error in /projects endpoint:', err);
             res.status(500).json({ error: 'Failed to list projects', details: err });
         }
     });
     router.post('/projects/create', async (req, res) => {
         try {
             const auth = await config.authProvider(req);
+            if (!auth ||
+                !auth.userId ||
+                !auth.role) {
+                return res.status(401).json({ error: 'Unauthorized' });
+            }
             if (auth.role !== 'admin' && auth.role !== 'editor') {
                 return res.status(403).json({ error: 'Permission denied' });
             }
@@ -143,6 +186,11 @@ function createStreamByRouter(config) {
     router.get('/projects/:id', async (req, res) => {
         try {
             const auth = await config.authProvider(req);
+            if (!auth ||
+                !auth.userId ||
+                !auth.role) {
+                return res.status(401).json({ error: 'Unauthorized' });
+            }
             const projectId = req.params.id;
             const project = await Project.findOne({ _id: projectId });
             if (!project) {
@@ -160,6 +208,11 @@ function createStreamByRouter(config) {
     router.patch('/projects/:id', async (req, res) => {
         try {
             const auth = await config.authProvider(req);
+            if (!auth ||
+                !auth.userId ||
+                !auth.role) {
+                return res.status(401).json({ error: 'Unauthorized' });
+            }
             if (auth.role !== 'admin' && auth.role !== 'editor') {
                 return res.status(403).json({ error: 'Permission denied' });
             }
@@ -188,6 +241,11 @@ function createStreamByRouter(config) {
     router.delete('/projects/:id', async (req, res) => {
         try {
             const auth = await config.authProvider(req);
+            if (!auth ||
+                !auth.userId ||
+                !auth.role) {
+                return res.status(401).json({ error: 'Unauthorized' });
+            }
             const projectId = req.params.id;
             const project = await Project.findOne({ _id: projectId });
             if (!project) {
@@ -206,6 +264,11 @@ function createStreamByRouter(config) {
     router.patch('/projects/:id/archive', async (req, res) => {
         try {
             const auth = await config.authProvider(req);
+            if (!auth ||
+                !auth.userId ||
+                !auth.role) {
+                return res.status(401).json({ error: 'Unauthorized' });
+            }
             const projectId = req.params.id;
             const project = await Project.findOne({ _id: projectId });
             if (!project || !isProjectMember(project, auth.userId)) {
@@ -234,6 +297,11 @@ function createStreamByRouter(config) {
     router.patch('/projects/:id/unarchive', async (req, res) => {
         try {
             const auth = await config.authProvider(req);
+            if (!auth ||
+                !auth.userId ||
+                !auth.role) {
+                return res.status(401).json({ error: 'Unauthorized' });
+            }
             const projectId = req.params.id;
             const project = await Project.findOne({ _id: projectId });
             if (!project || !isProjectMember(project, auth.userId)) {
@@ -262,6 +330,11 @@ function createStreamByRouter(config) {
     router.get('/projects/:id/exports/:export_id', async (req, res) => {
         try {
             const auth = await config.authProvider(req);
+            if (!auth ||
+                !auth.userId ||
+                !auth.role) {
+                return res.status(401).json({ error: 'Unauthorized' });
+            }
             const projectId = req.params.id;
             const exportId = req.params.export_id;
             const project = await Project.findOne({ _id: projectId });
@@ -281,6 +354,11 @@ function createStreamByRouter(config) {
     router.post('/projects/:id/exports', async (req, res) => {
         try {
             const auth = await config.authProvider(req);
+            if (!auth ||
+                !auth.userId ||
+                !auth.role) {
+                return res.status(401).json({ error: 'Unauthorized' });
+            }
             const projectId = req.params.id;
             const { name, description, collectionName } = req.body;
             if (!name || !collectionName) {
@@ -296,7 +374,6 @@ function createStreamByRouter(config) {
                 collectionName,
                 projectId
             });
-            await Project.update({ _id: projectId }, { $push: { exports: newExport._id } });
             res.status(201).json({ data: { ...newExport, id: newExport._id || newExport.id, _id: undefined } });
         }
         catch (err) {
@@ -306,6 +383,11 @@ function createStreamByRouter(config) {
     router.get('/projects/:id/members', async (req, res) => {
         try {
             const auth = await config.authProvider(req);
+            if (!auth ||
+                !auth.userId ||
+                !auth.role) {
+                return res.status(401).json({ error: 'Unauthorized' });
+            }
             const projectId = req.params.id;
             const project = await Project.findOne({ _id: projectId });
             if (!project) {