streamby-core 0.27.2 → 0.27.4

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/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 });
@@ -318,64 +342,61 @@ function exportRouter(config) {
             let data;
             if (exportMetadata.nodeSchema) {
                 data = await (0, pipeline_1.executePipeline)(exportMetadata.nodeSchema, project, config);
+                return res.json(data ?? null);
             }
-            else {
-                const targetDb = config.databases?.find(db => db.type === project.dbType);
-                if (!targetDb) {
-                    return res.status(500).json({ message: `Database connection not found for type ${project.dbType}` });
+            // Legacy path: raw JSON or external API export
+            const targetDb = config.databases?.find(db => db.type === project.dbType);
+            if (!targetDb) {
+                return res.status(500).json({ message: `Database connection not found for type ${project.dbType}` });
+            }
+            const connection = (0, connectionManager_1.getConnection)(targetDb.id);
+            if (project.dbType === 'nosql') {
+                const db = connection.client.db();
+                if (exportMetadata.type === 'json') {
+                    const rawData = await db.collection('exports').findOne({ _id: new mongodb_1.ObjectId(exportMetadata.id.toString()) });
+                    data = rawData ? rawData.json : null;
                 }
-                const connection = (0, connectionManager_1.getConnection)(targetDb.id);
-                if (project.dbType === 'nosql') {
-                    const db = connection.client.db();
-                    if (exportMetadata.type === 'json') {
-                        const rawData = await db.collection(exportMetadata.collectionName).findOne({ _id: new mongodb_1.ObjectId(exportMetadata.id) });
-                        data = rawData ? rawData.json : null;
-                    }
-                    else if (exportMetadata.type === 'externalApi') {
-                        let headers = {};
-                        if (exportMetadata.credentialId) {
-                            if (!(0, encryption_1.isEncryptionKeySet)()) {
-                                throw new Error('Encryption key is not set. Cannot use encrypted credentials.');
-                            }
-                            const credential = project.credentials?.find((cred) => cred.id === exportMetadata.credentialId);
-                            if (!credential) {
-                                throw new Error(`Credential with ID ${exportMetadata.credentialId} not found.`);
-                            }
-                            const decryptedValue = (0, encryption_1.decrypt)(credential.encryptedValue);
-                            const authPrefix = exportMetadata.prefix ? `${exportMetadata.prefix} ` : '';
-                            headers = {
-                                'Authorization': `${authPrefix}${decryptedValue}`,
-                                'Content-Type': 'application/json',
-                            };
-                        }
-                        try {
-                            const response = await fetch(exportMetadata.apiUrl, { headers });
-                            if (!response.ok) {
-                                throw new Error(`Failed to fetch from external API: ${response.statusText}`);
-                            }
-                            data = await response.json();
+                else if (exportMetadata.type === 'externalApi') {
+                    let headers = {};
+                    if (exportMetadata.credentialId) {
+                        if (!(0, encryption_1.isEncryptionKeySet)()) {
+                            throw new Error('Encryption key is not set. Cannot use encrypted credentials.');
                         }
-                        catch (error) {
-                            throw new Error(`Error fetching from external API: ${error.message}`);
+                        const credential = project.credentials?.find((cred) => cred.id === exportMetadata.credentialId);
+                        if (!credential) {
+                            throw new Error(`Credential with ID ${exportMetadata.credentialId} not found.`);
                         }
-                        if (exportMetadata.fields && exportMetadata.fields.length > 0) {
-                            data = data.map((item) => {
-                                return exportMetadata.fields.reduce((filtered, field) => {
-                                    filtered[field.name] = item[field.name];
-                                    return filtered;
-                                }, {});
-                            });
+                        const decryptedValue = (0, encryption_1.decrypt)(credential.encryptedValue);
+                        const authPrefix = exportMetadata.prefix ? `${exportMetadata.prefix} ` : '';
+                        headers = {
+                            'Authorization': `${authPrefix}${decryptedValue}`,
+                            'Content-Type': 'application/json',
+                        };
+                    }
+                    try {
+                        const response = await fetch(exportMetadata.apiUrl, { headers });
+                        if (!response.ok) {
+                            throw new Error(`Failed to fetch from external API: ${response.statusText}`);
                         }
+                        data = await response.json();
+                    }
+                    catch (error) {
+                        throw new Error(`Error fetching from external API: ${error.message}`);
+                    }
+                    if (exportMetadata.fields && exportMetadata.fields.length > 0) {
+                        data = data.map((item) => {
+                            return exportMetadata.fields.reduce((filtered, field) => {
+                                filtered[field.name] = item[field.name];
+                                return filtered;
+                            }, {});
+                        });
                     }
                 }
-                else if (project.dbType === 'sql') {
-                    return res.status(501).json({ message: 'SQL public exports not yet implemented' });
-                }
-            } // end legacy else block
-            if (data === null || data === undefined) {
-                return res.status(404).json({ message: 'Export data not found' });
             }
-            res.json(data);
+            else if (project.dbType === 'sql') {
+                return res.status(501).json({ message: 'SQL public exports not yet implemented' });
+            }
+            res.json(data ?? null);
         }
         catch (err) {
             res.status(500).json({ message: 'Failed to fetch public export data', details: err.message });

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;
@@ -219,14 +229,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

@@ -20,22 +20,19 @@ async function createExport(config, projectId, description, exportName, dbType,
     const resolvedDbType = targetDb.type;
     let exportId;
     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;
     }
     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',
@@ -46,8 +43,10 @@ async function createExport(config, projectId, description, exportName, dbType,
         useCredentials,
         description,
         storageDbId: targetDb.id,
+        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.`);
@@ -72,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
@@ -86,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 });
@@ -108,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/package.json

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