streamby-core 0.27.3 → 0.28.0

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

@@ -1,12 +1,7 @@
 import { MongoClient, Document } from 'mongodb';
-import { FieldDefinition, NodeSchema } from '../../types';
+import { NodeSchema } from '../../types';
 export declare const ensureCollectionsExist: (client: MongoClient) => Promise<void>;
-export declare const createNoSQLExportCollection: (connection: MongoClient, projectId: string, exportName: string, fields: FieldDefinition[]) => Promise<{
-    collectionName: string;
-    exportId: string;
-}>;
-export declare const createNoSQLRawExportCollection: (connection: MongoClient, projectId: string, exportName: string, method: string, nodeSchema?: NodeSchema) => Promise<{
-    collectionName: string;
+export declare const createNoSQLExportCollection: (connection: MongoClient, projectId: string, exportName: string, method: string, nodeSchema?: NodeSchema) => Promise<{
     exportId: string;
 }>;
 export declare const nosqlAdapter: {

package/dist/adapters/database/nosql.js

@@ -1,45 +1,32 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.nosqlAdapter = exports.createNoSQLRawExportCollection = exports.createNoSQLExportCollection = exports.ensureCollectionsExist = void 0;
+exports.nosqlAdapter = exports.createNoSQLExportCollection = 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
+    await db.collection('projects').findOne({});
     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
+    await db.collection('exports').findOne({});
     console.log('✅ "exports" collection ensured to exist.');
+    await db.collection('records').findOne({});
+    console.log('✅ "records" collection ensured to exist.');
+    await db.collection('_tables').findOne({});
+    console.log('✅ "_tables" collection ensured to exist.');
 };
 exports.ensureCollectionsExist = ensureCollectionsExist;
-const createNoSQLExportCollection = async (connection, projectId, exportName, fields) => {
+const createNoSQLExportCollection = async (connection, projectId, exportName, method, nodeSchema) => {
     const db = connection.db();
-    const slug = exportName.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
-    const collectionName = `export_${projectId}_${slug}`;
-    // Create the collection implicitly by inserting the metadata document
-    const metadataDocument = {
-        __metadata: {
-            fields,
-            createdAt: new Date(),
-            updatedAt: new Date(),
-        },
-    };
-    await db.collection(collectionName).insertOne(metadataDocument);
-    console.log(`✅ Collection '${collectionName}' created with metadata.`);
-    return { collectionName, exportId: collectionName };
+    const result = await db.collection('exports').insertOne({
+        projectId,
+        name: exportName,
+        method,
+        nodeSchema,
+        createdAt: new Date(),
+        updatedAt: new Date(),
+    });
+    return { exportId: result.insertedId.toHexString() };
 };
 exports.createNoSQLExportCollection = createNoSQLExportCollection;
-const createNoSQLRawExportCollection = async (connection, projectId, exportName, method, nodeSchema) => {
-    const db = connection.db();
-    const collectionName = projectId;
-    const result = await db.collection(collectionName).insertOne({ nodeSchema, name: exportName, method, createdAt: new Date(), updatedAt: new Date() });
-    return { collectionName, exportId: result.insertedId.toHexString() };
-};
-exports.createNoSQLRawExportCollection = createNoSQLRawExportCollection;
 exports.nosqlAdapter = {
     find: async (connection, tableName, filter) => {
         const db = connection.db();

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

@@ -1,11 +1,5 @@
 import { Pool } from 'pg';
-import { FieldDefinition } from '../../types';
-export declare const createSQLExportTable: (connection: Pool, projectId: string, exportName: string, fields: FieldDefinition[]) => Promise<{
-    collectionName: string;
-    exportId: string;
-}>;
-export declare const createSQLRawExportTable: (connection: Pool, projectId: string, exportName: string, nodeSchema?: any) => Promise<{
-    collectionName: string;
+export declare const createSQLExportTable: (connection: Pool, projectId: string, exportName: string, nodeSchema?: any) => Promise<{
     exportId: string;
 }>;
 export declare const sqlAdapter: {

package/dist/adapters/database/sql.js

@@ -1,51 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.sqlAdapter = exports.createSQLRawExportTable = exports.createSQLExportTable = void 0;
+exports.sqlAdapter = exports.createSQLExportTable = void 0;
 const crypto_1 = require("crypto");
-const createSQLExportTable = async (connection, projectId, exportName, fields) => {
-    const slug = exportName.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
-    const tableName = `export_${projectId}_${slug}`;
-    const columns = fields.map(field => `"${field.name}" ${field.type}`).join(',');
-    const createTableQuery = `
-    CREATE TABLE IF NOT EXISTS "${tableName}" (
-      id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
-      "projectId" UUID NOT NULL,
-      __metadata JSONB NOT NULL,
-      ${columns ? `, ${columns}` : ''}
-    );
-  `;
-    await connection.query(createTableQuery);
-    console.log(`✅ Table '${tableName}' created with metadata.`);
-    const metadata = {
-        fields,
-        createdAt: new Date(),
-        updatedAt: new Date(),
-    };
-    // Insert metadata as the first row, or a dedicated metadata row
-    // For simplicity, we'll just create the table with the metadata column.
-    // Actual metadata insertion for validation would happen on data inserts.
-    return { collectionName: tableName, exportId: tableName };
-};
-exports.createSQLExportTable = createSQLExportTable;
-const createSQLRawExportTable = async (connection, projectId, exportName, nodeSchema) => {
-    const tableName = projectId;
+function serializeForPg(v) {
+    if (Array.isArray(v) || (v !== null && typeof v === 'object' && !(v instanceof Date))) {
+        return JSON.stringify(v);
+    }
+    return v;
+}
+const createSQLExportTable = async (connection, projectId, exportName, nodeSchema) => {
     const exportId = (0, crypto_1.randomUUID)();
-    const createTableQuery = `
-    CREATE TABLE IF NOT EXISTS "${tableName}" (
-      id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
-      node_schema JSONB,
-      name TEXT,
-      method TEXT,
-      created_at TIMESTAMPTZ DEFAULT NOW(),
-      updated_at TIMESTAMPTZ DEFAULT NOW()
-    );
-  `;
-    await connection.query(createTableQuery);
-    await connection.query(`INSERT INTO "${tableName}" (id, node_schema, name, method) VALUES ($1, $2, $3, $4)`, [exportId, nodeSchema ? JSON.stringify(nodeSchema) : null, exportName, 'GET']);
-    console.log(`✅ Raw table '${tableName}' created.`);
-    return { collectionName: tableName, exportId };
+    await connection.query(`INSERT INTO "exports" (id, "projectId", node_schema, name, method, created_at, updated_at)
+     VALUES ($1, $2, $3, $4, 'GET', NOW(), NOW())`, [exportId, projectId, nodeSchema ? JSON.stringify(nodeSchema) : null, exportName]);
+    return { exportId };
 };
-exports.createSQLRawExportTable = createSQLRawExportTable;
+exports.createSQLExportTable = createSQLExportTable;
 exports.sqlAdapter = {
     find: async (connection, tableName, filter, schema) => {
         const keys = Object.keys(filter);
@@ -69,7 +38,7 @@ exports.sqlAdapter = {
     },
     create: async (connection, tableName, data, schema) => {
         const keys = Object.keys(data).map(key => `"${key}"`).join(', ');
-        const values = Object.values(data);
+        const values = Object.values(data).map(serializeForPg);
         const placeholders = values.map((_, i) => `$${i + 1}`).join(', ');
         const fullTableName = schema ? `"${schema}"."${tableName}"` : `"${tableName}"`;
         const result = await connection.query(`INSERT INTO ${fullTableName} (${keys}) VALUES (${placeholders}) RETURNING *`, values);
@@ -78,7 +47,7 @@ exports.sqlAdapter = {
     update: async (connection, tableName, filter, data, schema) => {
         const dataKeys = Object.keys(data);
         const filterKeys = Object.keys(filter);
-        const values = [...Object.values(data), ...Object.values(filter)];
+        const values = [...Object.values(data).map(serializeForPg), ...Object.values(filter)];
         const setClause = dataKeys.map((key, i) => `"${key}" = $${i + 1}`).join(', ');
         const whereClause = filterKeys.map((key, i) => `"${key}" = $${dataKeys.length + i + 1}`).join(' AND ');
         const fullTableName = schema ? `"${schema}"."${tableName}"` : `"${tableName}"`;

package/dist/index.d.ts

@@ -1,3 +1,4 @@
 export { createStreamByRouter } from './middleware/createRouter';
 export { emitToUser } from './services/wsHub';
 export { createNotification } from './services/notification';
+export type { UserPlan, UserSubscription } from './types';

package/dist/middleware/createRouter.js

@@ -23,6 +23,7 @@ const connection_1 = require("./routes/connection");
 const dbConnection_1 = require("./routes/dbConnection");
 const storageConnection_1 = require("./routes/storageConnection");
 const notification_1 = require("./routes/notification");
+const subscription_1 = require("./routes/subscription");
 function createStreamByRouter(config) {
     const router = express_1.default.Router();
     if (config.encrypt)
@@ -42,6 +43,7 @@ function createStreamByRouter(config) {
         const mainDb = config.databases.find(db => db.main);
         if (mainDb) {
             (0, manager_1.registerModel)('users', [mainDb.id], 'users', 'accounts');
+            (0, manager_1.registerModel)('user_subscriptions', [mainDb.id], 'user_subscriptions', 'streamby');
         }
     }
     if (config.websocket?.server) {
@@ -50,6 +52,7 @@ function createStreamByRouter(config) {
     router.use((0, user_1.userRouter)(config));
     router.use((0, auth_2.authRouter)(config));
     router.use((0, auth_1.authenticate)(config));
+    router.use(subscription_1.ensureSubscription);
     router.use((0, export_1.exportRouter)(config));
     router.use((0, member_1.memberRouter)(config));
     router.use((0, storage_2.storageRouter)(config));
@@ -60,5 +63,6 @@ function createStreamByRouter(config) {
     router.use((0, dbConnection_1.dbConnectionRouter)(config));
     router.use((0, storageConnection_1.storageConnectionRouter)(config));
     router.use((0, notification_1.notificationRouter)(config));
+    router.use((0, subscription_1.subscriptionRouter)(config));
     return router;
 }

package/dist/middleware/public.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getExportRoute = getExportRoute;
 function getExportRoute(req, res, next) {
-    if (req.path.includes('/get-export/')) {
+    if (req.path.includes('/export/')) {
         return next();
     }
     return next();

package/dist/middleware/routes/export.js

@@ -84,12 +84,11 @@ function exportRouter(config) {
                     };
                 }
                 else if (exportMetadata.type === 'json') {
-                    const rawData = await db.collection(exportMetadata.collectionName).findOne({ _id: new mongodb_1.ObjectId(exportId) });
+                    const rawData = await db.collection('exports').findOne({ _id: new mongodb_1.ObjectId(exportId) });
                     data = {
                         json: rawData?.json,
                         name: rawData?.name,
                         method: rawData?.method,
-                        collectionName: rawData?.collectionName,
                         createdAt: rawData?.createdAt,
                         updatedAt: rawData?.updatedAt,
                         type: exportMetadata.type,
@@ -98,7 +97,7 @@ function exportRouter(config) {
                     };
                 }
                 else if (exportMetadata.type === 'externalApi') {
-                    const ProjectModel = (0, manager_1.getModel)('projects', 'nosql');
+                    const ProjectModel = (0, manager_1.getModel)('projects');
                     const currentProject = await ProjectModel.findOne({ _id: projectId });
                     if (!currentProject) {
                         return res.status(404).json({ message: 'Project not found.' });
@@ -144,14 +143,13 @@ function exportRouter(config) {
                     };
                 }
                 else {
-                    const rawData = await db.collection(exportMetadata.collectionName).findOne({ _id: new mongodb_1.ObjectId(exportId) });
+                    const rawData = await db.collection('exports').findOne({ _id: new mongodb_1.ObjectId(exportId) });
                     data = {
                         json: rawData?.json,
                         name: rawData?.name,
                         method: rawData?.method,
                         createdAt: rawData?.createdAt,
                         updatedAt: rawData?.updatedAt,
-                        collectionName: rawData?.collectionName,
                         type: exportMetadata.type,
                         credentialId: exportMetadata.credentialId,
                         description: rawData?.description,
@@ -160,7 +158,33 @@ function exportRouter(config) {
                 }
             }
             else if (project.dbType === 'sql') {
-                // ... SQL implementation needed
+                const pool = connection.client;
+                if (exportMetadata.nodeSchema) {
+                    data = {
+                        name: exportMetadata.name,
+                        description: exportMetadata.description,
+                        nodeSchema: exportMetadata.nodeSchema,
+                        useConnections: exportMetadata.useConnections,
+                        useCredentials: exportMetadata.useCredentials,
+                        type: exportMetadata.type,
+                    };
+                }
+                else {
+                    const result = await pool.query(`SELECT * FROM "exports" WHERE id = $1`, [exportId]);
+                    const rawData = result.rows[0];
+                    if (rawData) {
+                        data = {
+                            json: rawData.json,
+                            name: rawData.name,
+                            method: rawData.method,
+                            createdAt: rawData.created_at,
+                            updatedAt: rawData.updated_at,
+                            type: exportMetadata.type,
+                            fields: exportMetadata.fields,
+                            description: rawData.description,
+                        };
+                    }
+                }
             }
             if (!data) {
                 return res.status(404).json({ message: 'Export data not found' });
@@ -253,14 +277,14 @@ function exportRouter(config) {
             if (!exportMetadata) {
                 return res.status(404).json({ message: 'Export not found in this project' });
             }
-            await (0, export_1.deleteExport)(config, projectId, exportId, project.dbType, exportMetadata.name);
+            await (0, export_1.deleteExport)(config, projectId, exportId, project.dbType);
             res.status(200).json({ message: 'Export deleted successfully' });
         }
         catch (err) {
             res.status(500).json({ message: 'Failed to delete export', details: err.message });
         }
     });
-    router.get('/:projectId/get-export/:exportName', async (req, res) => {
+    router.get('/:projectId/export/:exportName', async (req, res) => {
         try {
             const { projectId, exportName } = req.params;
             const project = await Project.findOne({ _id: projectId });
@@ -328,9 +352,8 @@ function exportRouter(config) {
             const connection = (0, connectionManager_1.getConnection)(targetDb.id);
             if (project.dbType === 'nosql') {
                 const db = connection.client.db();
-                const legacyCollection = exportMetadata.collectionName ?? projectId;
                 if (exportMetadata.type === 'json') {
-                    const rawData = await db.collection(legacyCollection).findOne({ _id: new mongodb_1.ObjectId(exportMetadata.id.toString()) });
+                    const rawData = await db.collection('exports').findOne({ _id: new mongodb_1.ObjectId(exportMetadata.id.toString()) });
                     data = rawData ? rawData.json : null;
                 }
                 else if (exportMetadata.type === 'externalApi') {

package/dist/middleware/routes/member.js

@@ -197,6 +197,88 @@ function memberRouter(config) {
             res.status(500).json({ message: 'Failed to reject invitation', details: err.message });
         }
     });
+    router.post('/projects/:id/request-join', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const projectId = req.params.id;
+            const project = await Project.findOne({ _id: projectId });
+            if (!project) {
+                return res.status(404).json({ message: 'Project not found' });
+            }
+            if (project.public === false) {
+                return res.status(403).json({ message: 'This project is not open for join requests' });
+            }
+            const alreadyMember = project.members?.some((m) => m.userId?.toString() === auth.userId?.toString());
+            if (alreadyMember) {
+                return res.status(400).json({ message: 'You are already a member or have a pending request' });
+            }
+            const User = (0, manager_1.getModel)('users');
+            const user = await User.findOne({ _id: auth.userId });
+            const username = user?.username || auth.username;
+            if (project.dbType === 'sql') {
+                const connection = getSqlConnection();
+                if (!connection) {
+                    return res.status(503).json({ message: 'SQL connection not available' });
+                }
+                await sql_1.sqlAdapter.create(connection, 'project_members', {
+                    projectId,
+                    userId: auth.userId,
+                    role: 'viewer',
+                    archived: false,
+                    status: 'pending',
+                    invitedBy: auth.userId,
+                }, 'streamby');
+            }
+            else {
+                await Project.update({ _id: projectId }, {
+                    $push: { members: { userId: auth.userId, username, role: 'viewer', archived: false, status: 'pending', invitedBy: auth.userId } },
+                });
+            }
+            const admins = (project.members || []).filter((m) => m.role === 'admin' && m.status === 'active');
+            await Promise.all(admins.map((admin) => (0, notification_1.createNotification)(admin.userId, 'join_request', `${username} has requested to join "${project.name}"`, { projectId, userId: auth.userId })));
+            res.status(201).json({ message: 'Join request sent successfully' });
+        }
+        catch (err) {
+            res.status(500).json({ message: 'Failed to send join request', details: err.message });
+        }
+    });
+    router.patch('/projects/:id/members/:userId/approve', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { id: projectId, userId: targetUserId } = req.params;
+            const project = await Project.findOne({ _id: projectId });
+            if (!project) {
+                return res.status(404).json({ message: 'Project not found' });
+            }
+            const requestingMember = project.members?.find((m) => m.userId?.toString() === auth.userId?.toString());
+            if (!requestingMember || requestingMember.status !== 'active' || requestingMember.role !== 'admin') {
+                return res.status(403).json({ message: 'Only project admins can approve requests' });
+            }
+            const targetMember = project.members?.find((m) => m.userId?.toString() === targetUserId?.toString());
+            if (!targetMember) {
+                return res.status(404).json({ message: 'Member not found in project' });
+            }
+            if (targetMember.status !== 'pending') {
+                return res.status(400).json({ message: 'No pending request for this user' });
+            }
+            if (project.dbType === 'sql') {
+                const connection = getSqlConnection();
+                if (!connection) {
+                    return res.status(503).json({ message: 'SQL connection not available' });
+                }
+                await sql_1.sqlAdapter.update(connection, 'project_members', { projectId, userId: targetUserId }, { status: 'active' }, 'streamby');
+            }
+            else {
+                const updatedMembers = project.members.map((m) => m.userId?.toString() === targetUserId ? { ...m, status: 'active' } : m);
+                await Project.update({ _id: projectId }, { members: updatedMembers });
+            }
+            await (0, notification_1.createNotification)(targetUserId, 'join_approved', `Your request to join "${project.name}" has been approved`, { projectId });
+            res.status(200).json({ message: 'Join request approved' });
+        }
+        catch (err) {
+            res.status(500).json({ message: 'Failed to approve join request', details: err.message });
+        }
+    });
     router.delete('/projects/:id/members/:userId', async (req, res) => {
         try {
             const auth = req.auth;

package/dist/middleware/routes/project.js

@@ -44,13 +44,40 @@ function projectRouter(config) {
             res.status(500).json({ message: 'Failed to list projects', details: err });
         }
     });
+    router.get('/projects/explore', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const allProjects = await Project.find({});
+            const result = allProjects
+                .filter((p) => p.public !== false)
+                .map((p) => ({
+                id: p._id || p.id,
+                name: p.name,
+                description: p.description || '',
+                image: p.image || '',
+                memberCount: (p.members || []).filter((m) => m.status === 'active').length,
+                isMember: (p.members || []).some((m) => m.userId?.toString() === auth.userId && m.status === 'active'),
+                hasPendingRequest: (p.members || []).some((m) => m.userId?.toString() === auth.userId && m.status === 'pending'),
+            }));
+            res.json({ projects: result });
+        }
+        catch (err) {
+            res.status(500).json({ message: 'Failed to explore projects', details: err.message });
+        }
+    });
     router.post('/projects/create', async (req, res) => {
         try {
             const auth = req.auth;
+            if (req.subscription === 'freemium') {
+                return res.status(403).json({ error: 'Freemium users cannot create projects' });
+            }
             if (auth.role !== 'admin' && auth.role !== 'editor') {
                 return res.status(403).json({ message: 'Permission denied' });
             }
-            const { name, description, image, allowedOrigin } = req.body;
+            const { name, description, image, allowedOrigin, public: isPublic = true } = req.body;
+            if (isPublic === false && req.subscription === 'freemium') {
+                return res.status(403).json({ error: 'Private projects require a subscriber plan' });
+            }
             const mainDb = config.databases?.find(db => db.main) ?? config.databases?.[0];
             if (!mainDb) {
                 return res.status(500).json({ message: 'No database configured' });
@@ -67,6 +94,7 @@ function projectRouter(config) {
                 description: description || '',
                 image: image || '',
                 allowedOrigin: allowedOrigin || [],
+                public: isPublic,
                 members: [{ userId: auth.userId, username: user.username, role: "admin", status: "active", archived: false }],
             });
             const allProjects = await Project.find({});

package/dist/middleware/routes/subscription.d.ts

@@ -0,0 +1,4 @@
+import { Router, Request, Response, NextFunction } from 'express';
+import { StreamByConfig } from '../../types';
+export declare const ensureSubscription: (req: Request, res: Response, next: NextFunction) => Promise<void>;
+export declare function subscriptionRouter(config: StreamByConfig): Router;

package/dist/middleware/routes/subscription.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureSubscription = void 0;
+exports.subscriptionRouter = subscriptionRouter;
+const express_1 = require("express");
+const manager_1 = require("../../models/manager");
+const resolveSubscription = async (auth) => {
+    const Subscription = (0, manager_1.getModel)('user_subscriptions');
+    const existing = await Subscription.findOne({ user_id: auth.userId });
+    if (existing)
+        return existing.plan;
+    const plan = auth.role === 'admin' ? 'admin' : 'freemium';
+    await Subscription.create({ user_id: auth.userId, plan, dbType: 'sql' });
+    return plan;
+};
+const ensureSubscription = async (req, res, next) => {
+    try {
+        const auth = req.auth;
+        const plan = await resolveSubscription(auth);
+        req.subscription = plan;
+        next();
+    }
+    catch (err) {
+        res.status(403).json({ error: 'Unauthorized', details: err.message });
+    }
+};
+exports.ensureSubscription = ensureSubscription;
+function subscriptionRouter(config) {
+    const router = (0, express_1.Router)();
+    router.get('/user/subscription', async (req, res) => {
+        res.json({ subscription: req.subscription });
+    });
+    return router;
+}

package/dist/models/Model.js

@@ -129,6 +129,11 @@ class Model {
                             archived: member.archived,
                         }));
                     }
+                    // Track which connection found this record so update() routes correctly
+                    try {
+                        Object.defineProperty(transformedResult, '__foundByConnectionId', { value: connectionId, enumerable: false, writable: true });
+                    }
+                    catch { }
                     return transformedResult;
                 }
             }
@@ -144,8 +149,13 @@ class Model {
                     }
                 }
                 const result = await nosql_1.nosqlAdapter.findOne(connection, this.tableName, processedFilter);
-                if (result)
+                if (result) {
+                    try {
+                        Object.defineProperty(result, '__foundByConnectionId', { value: connectionId, enumerable: false, writable: true });
+                    }
+                    catch { }
                     return result;
+                }
             }
         }
         return null;
@@ -170,8 +180,10 @@ class Model {
                 if (this.tableName === 'projects' && key === 'members') {
                     membersToInsert = data[key];
                 }
-                else if (this.tableName === 'projects' && key.toLowerCase() === 'dbtype') {
-                    dataToInsert["dbType"] = data[key];
+                else if (key.toLowerCase() === 'dbtype') {
+                    if (this.tableName === 'projects')
+                        dataToInsert["dbType"] = data[key];
+                    // else: routing hint only — never a real column
                 }
                 else {
                     dataToInsert[key] = data[key];
@@ -219,14 +231,17 @@ class Model {
         if (!existingProject) {
             return null; // Project not found
         }
-        const targetDbType = existingProject.dbType; // Get the actual dbType of the project
-        // Find the connection that matches the targetDbType (only among active connections)
         const activeConnectionIds = this.connectionIds.filter(id => (0, connectionManager_1.getConnectedIds)().includes(id));
-        const clientEntry = activeConnectionIds
-            .map(id => (0, connectionManager_1.getConnection)(id))
-            .find(entry => entry.type === targetDbType);
+        // Use the connection where findOne actually found the record, not project.dbType.
+        // project.dbType is the DATA db type (where the project's collections live), not the
+        // STORAGE db type (where the project document itself lives). Using dbType here would
+        // route SQL-stored projects with dbType:'nosql' to MongoDB, causing update failures.
+        const storageConnectionId = existingProject.__foundByConnectionId;
+        const clientEntry = (storageConnectionId && activeConnectionIds.includes(storageConnectionId))
+            ? (0, connectionManager_1.getConnection)(storageConnectionId)
+            : activeConnectionIds.map(id => (0, connectionManager_1.getConnection)(id)).find(entry => entry.type === existingProject.dbType);
         if (!clientEntry) {
-            throw new Error(`No active connection found for database type: ${targetDbType}`);
+            throw new Error(`No active connection found for database type: ${existingProject.dbType}`);
         }
         const connection = clientEntry.client;
         const dbType = clientEntry.type; // This will be the targetDbType

package/dist/services/auth.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.authenticate = void 0;
 exports.checkRole = checkRole;
 const authenticate = (config) => async (req, res, next) => {
-    if (req.path.includes('/get-export/')) {
+    if (req.path.includes('/export/')) {
         return next();
     }
     try {

package/dist/services/credential.js

@@ -10,7 +10,7 @@ async function addCredential(config, projectId, newCredential) {
     if (!(0, encryption_1.isEncryptionKeySet)()) {
         throw new Error('Encryption key is not set. Cannot add credentials.');
     }
-    const ProjectModel = (0, manager_1.getModel)('projects', 'nosql');
+    const ProjectModel = (0, manager_1.getModel)('projects');
     const project = await ProjectModel.findOne({ _id: projectId });
     if (!project) {
         throw new Error('Project not found.');
@@ -31,7 +31,7 @@ async function updateCredential(config, projectId, credentialId, updates) {
     if (!(0, encryption_1.isEncryptionKeySet)()) {
         throw new Error('Encryption key is not set. Cannot update credentials.');
     }
-    const ProjectModel = (0, manager_1.getModel)('projects', 'nosql');
+    const ProjectModel = (0, manager_1.getModel)('projects');
     const project = await ProjectModel.findOne({ _id: projectId });
     if (!project) {
         throw new Error('Project not found.');
@@ -57,7 +57,7 @@ async function updateCredential(config, projectId, credentialId, updates) {
     return updatedProject;
 }
 async function deleteCredential(config, projectId, credentialId) {
-    const ProjectModel = (0, manager_1.getModel)('projects', 'nosql');
+    const ProjectModel = (0, manager_1.getModel)('projects');
     const project = await ProjectModel.findOne({ _id: projectId });
     if (!project) {
         throw new Error('Project not found.');

package/dist/services/dbConnection.js

@@ -172,10 +172,16 @@ async function deleteRecord(connectionString, dbType, tableName, recordId) {
 }
 // ─── Internal (pool-based) variants ──────────────────────────────────────────
 // These operate on already-connected Pool / MongoClient from connectionManager.
+//
+// nosql storage pattern: all user records go into a single 'records' collection
+// with _projectId and _tableName metadata fields. Table membership is tracked in
+// a separate '_tables' collection. SQL keeps the legacy db_{projectId}_{tableName}
+// table-per-collection pattern which is appropriate for relational databases.
 function quoteSqlTable(tableName) {
     const parts = tableName.split('.');
     return parts.length === 2 ? `"${parts[0]}"."${parts[1]}"` : `"${tableName}"`;
 }
+const RECORD_META_PROJECTION = { _projectId: 0, _tableName: 0 };
 async function listTablesInternal(client, dbType, projectId) {
     const prefix = projectId ? `db_${projectId}_` : null;
     if (dbType === 'sql') {
@@ -190,40 +196,54 @@ async function listTablesInternal(client, dbType, projectId) {
             return prefix ? full.slice(prefix.length) : full;
         });
     }
-    const cols = await client.db().listCollections().toArray();
-    const names = cols.map(c => c.name).sort();
-    if (!prefix)
-        return names;
-    return names.filter(n => n.startsWith(prefix)).map(n => n.slice(prefix.length));
+    const db = client.db();
+    if (!projectId) {
+        const cols = await db.listCollections().toArray();
+        return cols.map(c => c.name).sort();
+    }
+    const tables = await db.collection('_tables').find({ _projectId: projectId }).toArray();
+    return tables.map((t) => t.tableName).sort();
 }
 async function queryRecordsInternal(client, dbType, tableName, limit = 50, offset = 0, projectId) {
-    const fullName = projectId ? `db_${projectId}_${tableName}` : tableName;
     if (dbType === 'sql') {
+        const fullName = projectId ? `db_${projectId}_${tableName}` : tableName;
         const result = await client.query(`SELECT * FROM ${quoteSqlTable(fullName)} LIMIT $1 OFFSET $2`, [limit, offset]);
         return result.rows;
     }
-    return client.db().collection(fullName).find().limit(limit).skip(offset).toArray();
+    const db = client.db();
+    const filter = {};
+    if (projectId)
+        filter._projectId = projectId;
+    if (tableName)
+        filter._tableName = tableName;
+    return db.collection('records').find(filter, { projection: RECORD_META_PROJECTION }).limit(limit).skip(offset).toArray();
 }
 async function queryRecordByIdInternal(client, dbType, tableName, recordId, projectId) {
-    const fullName = projectId ? `db_${projectId}_${tableName}` : tableName;
     if (dbType === 'sql') {
+        const fullName = projectId ? `db_${projectId}_${tableName}` : tableName;
         const result = await client.query(`SELECT * FROM ${quoteSqlTable(fullName)} WHERE id = $1 LIMIT 1`, [recordId]);
         return result.rows[0] ?? null;
     }
     const db = client.db();
-    let doc = await db.collection(fullName).findOne({ _id: recordId });
+    const meta = {};
+    if (projectId)
+        meta._projectId = projectId;
+    if (tableName)
+        meta._tableName = tableName;
+    const opts = { projection: RECORD_META_PROJECTION };
+    let doc = await db.collection('records').findOne({ ...meta, _id: recordId }, opts);
     if (!doc) {
         try {
             const { ObjectId } = await Promise.resolve().then(() => __importStar(require('mongodb')));
-            doc = await db.collection(fullName).findOne({ _id: new ObjectId(recordId) });
+            doc = await db.collection('records').findOne({ ...meta, _id: new ObjectId(recordId) }, opts);
         }
         catch { /* invalid ObjectId format — not found */ }
     }
     return doc;
 }
 async function createTableOrCollectionInternal(client, dbType, schema, projectId) {
-    const fullName = projectId ? `db_${projectId}_${schema.tableName}` : schema.tableName;
     if (dbType === 'sql') {
+        const fullName = projectId ? `db_${projectId}_${schema.tableName}` : schema.tableName;
         const columnDdl = schema.columns.map(col => {
             const nullable = col.nullable === false ? 'NOT NULL' : '';
             const pk = col.primaryKey ? 'PRIMARY KEY' : '';
@@ -232,11 +252,16 @@ async function createTableOrCollectionInternal(client, dbType, schema, projectId
         await client.query(`CREATE TABLE IF NOT EXISTS ${quoteSqlTable(fullName)} (${columnDdl})`);
         return;
     }
-    await client.db().createCollection(fullName);
+    const db = client.db();
+    await db.collection('_tables').insertOne({
+        _projectId: projectId ?? null,
+        tableName: schema.tableName,
+        createdAt: new Date(),
+    });
 }
 async function insertRecordInternal(client, dbType, tableName, record, projectId) {
-    const fullName = projectId ? `db_${projectId}_${tableName}` : tableName;
     if (dbType === 'sql') {
+        const fullName = projectId ? `db_${projectId}_${tableName}` : tableName;
         const keys = Object.keys(record);
         const values = Object.values(record);
         const cols = keys.map(k => `"${k}"`).join(', ');
@@ -244,12 +269,14 @@ async function insertRecordInternal(client, dbType, tableName, record, projectId
         const result = await client.query(`INSERT INTO ${quoteSqlTable(fullName)} (${cols}) VALUES (${placeholders}) RETURNING *`, values);
         return result.rows[0];
     }
-    const result = await client.db().collection(fullName).insertOne(record);
+    const db = client.db();
+    const doc = { _projectId: projectId ?? null, _tableName: tableName, ...record };
+    const result = await db.collection('records').insertOne(doc);
     return { ...record, _id: result.insertedId };
 }
 async function updateRecordInternal(client, dbType, tableName, recordId, updates, projectId) {
-    const fullName = projectId ? `db_${projectId}_${tableName}` : tableName;
     if (dbType === 'sql') {
+        const fullName = projectId ? `db_${projectId}_${tableName}` : tableName;
         const keys = Object.keys(updates).filter(k => k !== 'id');
         if (!keys.length)
             return null;
@@ -258,31 +285,41 @@ async function updateRecordInternal(client, dbType, tableName, recordId, updates
         return result.rows[0] ?? null;
     }
     const { ObjectId } = await Promise.resolve().then(() => __importStar(require('mongodb')));
-    const { _id, ...fields } = updates;
-    let filter;
+    const { _id, _projectId: _p, _tableName: _t, ...fields } = updates;
+    const meta = {};
+    if (projectId)
+        meta._projectId = projectId;
+    if (tableName)
+        meta._tableName = tableName;
+    let idFilter;
     try {
-        filter = { _id: new ObjectId(recordId) };
+        idFilter = new ObjectId(recordId);
     }
     catch {
-        filter = { _id: recordId };
+        idFilter = recordId;
     }
-    return client.db().collection(fullName).findOneAndUpdate(filter, { $set: fields }, { returnDocument: 'after' });
+    return client.db().collection('records').findOneAndUpdate({ ...meta, _id: idFilter }, { $set: fields }, { returnDocument: 'after', projection: RECORD_META_PROJECTION });
 }
 async function deleteRecordInternal(client, dbType, tableName, recordId, projectId) {
-    const fullName = projectId ? `db_${projectId}_${tableName}` : tableName;
     if (dbType === 'sql') {
+        const fullName = projectId ? `db_${projectId}_${tableName}` : tableName;
         const result = await client.query(`DELETE FROM ${quoteSqlTable(fullName)} WHERE id = $1`, [recordId]);
         return (result.rowCount ?? 0) > 0;
     }
     const { ObjectId } = await Promise.resolve().then(() => __importStar(require('mongodb')));
-    let filter;
+    const meta = {};
+    if (projectId)
+        meta._projectId = projectId;
+    if (tableName)
+        meta._tableName = tableName;
+    let idFilter;
     try {
-        filter = { _id: new ObjectId(recordId) };
+        idFilter = new ObjectId(recordId);
     }
     catch {
-        filter = { _id: recordId };
+        idFilter = recordId;
     }
-    const result = await client.db().collection(fullName).deleteOne(filter);
+    const result = await client.db().collection('records').deleteOne({ ...meta, _id: idFilter });
     return result.deletedCount > 0;
 }
 async function deleteTableOrCollection(connectionString, dbType, tableName) {
@@ -295,10 +332,17 @@ async function deleteTableOrCollection(connectionString, dbType, tableName) {
     });
 }
 async function deleteTableOrCollectionInternal(client, dbType, tableName, projectId) {
-    const fullName = projectId ? `db_${projectId}_${tableName}` : tableName;
     if (dbType === 'sql') {
+        const fullName = projectId ? `db_${projectId}_${tableName}` : tableName;
         await client.query(`DROP TABLE IF EXISTS ${quoteSqlTable(fullName)}`);
         return;
     }
-    await client.db().dropCollection(fullName);
+    const db = client.db();
+    const meta = {};
+    if (projectId)
+        meta._projectId = projectId;
+    if (tableName)
+        meta._tableName = tableName;
+    await db.collection('records').deleteMany(meta);
+    await db.collection('_tables').deleteOne({ _projectId: projectId ?? null, tableName });
 }

package/dist/services/export.d.ts

@@ -5,7 +5,7 @@ interface ExportResult {
 }
 export declare function createExport(config: StreamByConfig, projectId: string, description: string, exportName: string, dbType: DatabaseType, exportType: 'json' | 'externalApi', isPrivate?: boolean, allowedOrigin?: string[], nodeSchema?: NodeSchema, useConnections?: boolean, useCredentials?: boolean, storageDbId?: string): Promise<ExportResult>;
 export declare function updateExport(config: StreamByConfig, projectId: string, exportId: string, description: string, exportName: string, dbType: DatabaseType, exportType: 'json' | 'externalApi', isPrivate?: boolean, allowedOrigin?: string[], devMode?: boolean, devPorts?: number[], nodeSchema?: NodeSchema, useConnections?: boolean, useCredentials?: boolean): Promise<ExportResult>;
-export declare function deleteExport(config: StreamByConfig, projectId: string, exportId: string, dbType: DatabaseType, exportName: string): Promise<{
+export declare function deleteExport(config: StreamByConfig, projectId: string, exportId: string, dbType: DatabaseType): Promise<{
     message: string;
 }>;
 export {};

package/dist/services/export.js

@@ -19,25 +19,20 @@ async function createExport(config, projectId, description, exportName, dbType,
     const connection = (0, connectionManager_1.getConnection)(targetDb.id);
     const resolvedDbType = targetDb.type;
     let exportId;
-    let collectionName;
     if (resolvedDbType === 'nosql') {
-        const result = await (0, nosql_1.createNoSQLRawExportCollection)(connection.client, projectId, exportName, 'GET', nodeSchema);
+        const result = await (0, nosql_1.createNoSQLExportCollection)(connection.client, projectId, exportName, 'GET', nodeSchema);
         exportId = result.exportId;
-        collectionName = result.collectionName;
     }
     else if (resolvedDbType === 'sql') {
-        const result = await (0, sql_1.createSQLRawExportTable)(connection.client, projectId, exportName, nodeSchema);
+        const result = await (0, sql_1.createSQLExportTable)(connection.client, projectId, exportName, nodeSchema);
         exportId = result.exportId;
     }
     else {
         throw new Error('Unsupported database type');
     }
-    // Route the project document update to the correct DB based on where the project lives
-    const Project = (0, manager_1.getModel)('projects');
-    const project = await Project.findOne({ _id: projectId });
-    const isSqlProject = project?.dbType === 'sql';
+    const now = new Date();
     const exportEntry = {
-        id: isSqlProject ? exportId : new mongodb_1.ObjectId(exportId),
+        id: exportId, // Always a plain string; works for both UUID (SQL export) and ObjectId hex (nosql export)
         name: exportName,
         type: exportType,
         method: 'GET',
@@ -48,9 +43,10 @@ async function createExport(config, projectId, description, exportName, dbType,
         useCredentials,
         description,
         storageDbId: targetDb.id,
-        collectionName,
+        createdAt: now,
+        updatedAt: now,
     };
-    const ProjectModel = isSqlProject ? (0, manager_1.getModel)('projects', 'sql') : (0, manager_1.getModel)('projects', 'nosql');
+    const ProjectModel = (0, manager_1.getModel)('projects');
     const updated = await ProjectModel.update({ _id: projectId }, { $push: { exports: exportEntry } });
     if (!updated) {
         throw new Error(`Failed to save export entry to project ${projectId}. The project may not exist or the database update failed.`);
@@ -75,7 +71,7 @@ async function updateExport(config, projectId, exportId, description, exportName
     const connection = (0, connectionManager_1.getConnection)(targetDb.id);
     if (targetDb.type === 'nosql') {
         const db = connection.client.db();
-        await db.collection(projectId).updateOne({ _id: new mongodb_1.ObjectId(exportId) }, { $set: { nodeSchema, description, updatedAt: new Date() } });
+        await db.collection('exports').updateOne({ _id: new mongodb_1.ObjectId(exportId) }, { $set: { nodeSchema, description, updatedAt: new Date() } });
     }
     // SQL raw export table update would go here if needed in future
     // Update the export entry in the project document
@@ -89,12 +85,12 @@ async function updateExport(config, projectId, exportId, description, exportName
         await SqlProject.update({ _id: projectId }, { exports: updatedExports });
     }
     else {
-        const NoSQLProject = (0, manager_1.getModel)('projects', 'nosql');
+        const NoSQLProject = (0, manager_1.getModel)('projects');
         await NoSQLProject.update({ _id: new mongodb_1.ObjectId(projectId), 'exports.id': { $in: [new mongodb_1.ObjectId(exportId), exportId] } }, { $set: { 'exports.$.name': exportName, 'exports.$.private': isPrivate, 'exports.$.allowedOrigin': allowedOrigin, 'exports.$.devMode': devMode, 'exports.$.devPorts': devPorts, 'exports.$.nodeSchema': nodeSchema, 'exports.$.useConnections': useConnections, 'exports.$.useCredentials': useCredentials, 'exports.$.description': description } });
     }
     return { exportId, message: `${exportType} export updated successfully` };
 }
-async function deleteExport(config, projectId, exportId, dbType, exportName) {
+async function deleteExport(config, projectId, exportId, dbType) {
     // Resolve the project to find where its raw export data lives
     const Project = (0, manager_1.getModel)('projects');
     const project = await Project.findOne({ _id: projectId });
@@ -111,15 +107,15 @@ async function deleteExport(config, projectId, exportId, dbType, exportName) {
     const connection = (0, connectionManager_1.getConnection)(targetDb.id);
     if (targetDb.type === 'nosql') {
         const db = connection.client.db();
-        await db.collection(projectId).deleteOne({ _id: new mongodb_1.ObjectId(exportId) });
+        await db.collection('exports').deleteOne({ _id: new mongodb_1.ObjectId(exportId) });
     }
-    // SQL raw export table row deletion would go here if needed in future
+    // SQL export row deletion would go here if needed in future
     if (isSqlProject) {
         const SqlProject = (0, manager_1.getModel)('projects', 'sql');
         await SqlProject.update({ _id: projectId }, { $pull: { exports: { id: exportId } } });
     }
     else {
-        const NoSQLProject = (0, manager_1.getModel)('projects', 'nosql');
+        const NoSQLProject = (0, manager_1.getModel)('projects');
         await NoSQLProject.update({ _id: new mongodb_1.ObjectId(projectId) }, { $pull: { exports: { id: new mongodb_1.ObjectId(exportId) } } });
     }
     return { message: 'Export deleted successfully' };

package/dist/services/pipeline.js

@@ -91,9 +91,10 @@ async function executePipeline(nodeSchema, project, config) {
                 continue;
             const connectionId = node.data?.connectionId;
             const recordId = node.data?.recordId;
+            const projectIdentifier = project._id?.toString() ?? project.id;
             const fetchData = async (client, type) => recordId
-                ? (0, dbConnection_1.queryRecordByIdInternal)(client, type, tableName, recordId, project.id)
-                : (0, dbConnection_1.queryRecordsInternal)(client, type, tableName, 500, 0, project.id);
+                ? (0, dbConnection_1.queryRecordByIdInternal)(client, type, tableName, recordId, projectIdentifier)
+                : (0, dbConnection_1.queryRecordsInternal)(client, type, tableName, 500, 0, projectIdentifier);
             if (connectionId) {
                 const { client, type } = (0, connectionManager_1.getConnection)(connectionId);
                 dataResults.push(await fetchData(client, type));

package/dist/types/index.d.ts

@@ -54,6 +54,7 @@ export interface ProjectInfo {
     dbType?: DatabaseType;
     name: string;
     image?: string;
+    public?: boolean;
     members?: {
         role: 'viewer' | 'editor' | 'admin';
         userId: string;
@@ -135,6 +136,14 @@ export interface Auth {
     role: 'viewer' | 'editor' | 'admin';
 }
 export type AuthProvider = (req: Request) => Promise<Auth>;
+export type UserPlan = 'freemium' | 'subscriber' | 'admin';
+export interface UserSubscription {
+    id: string;
+    user_id: string;
+    plan: UserPlan;
+    created_at: Date;
+    updated_at: Date;
+}
 export type ExternalDbType = 'postgresql' | 'mongodb';
 export interface DbConnection {
     id: string;

package/package.json

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