streamby-core 0.26.10 → 0.27.1

package/dist/middleware/routes/export.js

@@ -168,8 +168,11 @@ function exportRouter(config) {
             let responseData;
             responseData = {
                 ...data,
+                id: exportId,
                 allowedOrigin: exportMetadata.allowedOrigin,
                 private: exportMetadata.private,
+                devMode: exportMetadata.devMode,
+                devPorts: exportMetadata.devPorts,
             };
             res.json({
                 data: responseData,
@@ -189,7 +192,7 @@ function exportRouter(config) {
                 return res.status(401).json({ message: 'Unauthorized' });
             }
             const projectId = req.params.id;
-            const { name, description, isPrivate, allowedOrigin, useConnections, useCredentials, nodeSchema } = req.body;
+            const { name, description, isPrivate, allowedOrigin, useConnections, useCredentials, nodeSchema, storageDbId } = req.body;
             if (!name) {
                 return res.status(400).json({ message: 'Missing export name' });
             }
@@ -199,7 +202,9 @@ function exportRouter(config) {
             if (!project || !(0, auth_1.isProjectMember)(project, auth.userId)) {
                 return res.status(403).json({ message: 'Unauthorized project access' });
             }
-            const result = await (0, export_1.createExport)(config, projectId, description, name, project.dbType, exportType, isPrivate, allowedOrigin, resolvedNodeSchema, useConnections, useCredentials);
+            const mainDb = config.databases?.find(db => db.main) ?? config.databases?.[0];
+            const dbType = mainDb?.type ?? 'nosql';
+            const result = await (0, export_1.createExport)(config, projectId, description, name, dbType, exportType, isPrivate, allowedOrigin, resolvedNodeSchema, useConnections, useCredentials, storageDbId);
             res.status(201).json({ data: result, message: result.message });
         }
         catch (err) {
@@ -213,7 +218,7 @@ function exportRouter(config) {
                 return res.status(401).json({ message: 'Unauthorized' });
             }
             const { id: projectId, export_id: exportId } = req.params;
-            const { name, description, isPrivate, allowedOrigin, useConnections, useCredentials, nodeSchema } = req.body;
+            const { name, description, isPrivate, allowedOrigin, devMode, devPorts, useConnections, useCredentials, nodeSchema } = req.body;
             const project = await Project.findOne({ _id: projectId });
             if (!project || !(0, auth_1.isProjectMember)(project, auth.userId)) {
                 return res.status(403).json({ message: 'Unauthorized project access' });
@@ -226,7 +231,7 @@ function exportRouter(config) {
             const resolvedNodeSchema = nodeSchema ?? exportMetadata.nodeSchema;
             const resolvedUseConnections = useConnections ?? exportMetadata.useConnections;
             const exportType = resolvedUseConnections ? 'externalApi' : 'json';
-            const result = await (0, export_1.updateExport)(config, projectId, exportId, description ?? exportMetadata.description, resolvedName, project.dbType, exportType, isPrivate ?? exportMetadata.private, allowedOrigin ?? exportMetadata.allowedOrigin, resolvedNodeSchema, resolvedUseConnections, useCredentials ?? exportMetadata.useCredentials);
+            const result = await (0, export_1.updateExport)(config, projectId, exportId, description ?? exportMetadata.description, resolvedName, project.dbType, exportType, isPrivate ?? exportMetadata.private, allowedOrigin ?? exportMetadata.allowedOrigin, devMode ?? exportMetadata.devMode, devPorts ?? exportMetadata.devPorts, resolvedNodeSchema, resolvedUseConnections, useCredentials ?? exportMetadata.useCredentials);
             res.status(200).json({ data: result, message: result.message });
         }
         catch (err) {
@@ -282,14 +287,33 @@ function exportRouter(config) {
                     }
                 }
             }
-            // If there's no origin header, deny access unless the effective scope is public.
-            if (!origin && !(effectiveAllowedOrigins && effectiveAllowedOrigins.includes('*'))) {
-                return res.status(403).json({ message: 'Origin header required' });
+            // Dev mode: auto-allow localhost requests on configured ports.
+            let devModeAllowed = false;
+            if (exportMetadata.devMode && origin) {
+                const match = origin.match(/^https?:\/\/localhost:(\d+)$/);
+                if (match) {
+                    const port = parseInt(match[1]);
+                    const allowedPorts = exportMetadata.devPorts?.length
+                        ? exportMetadata.devPorts
+                        : [3000, 5173, 8080, 4200];
+                    if (allowedPorts.includes(port)) {
+                        devModeAllowed = true;
+                        res.header('Access-Control-Allow-Origin', origin);
+                        res.header('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS');
+                        res.header('Access-Control-Allow-Headers', 'Content-Type, Authorization');
+                    }
+                }
             }
-            // Check for public access ('*') or if the request's origin is in the effective list.
-            const isAllowed = effectiveAllowedOrigins && (effectiveAllowedOrigins.includes('*') || (origin && effectiveAllowedOrigins.includes(origin)));
-            if (!isAllowed) {
-                return res.status(403).json({ message: 'Unauthorized' });
+            if (!devModeAllowed) {
+                // If there's no origin header, deny access unless the effective scope is public.
+                if (!origin && !(effectiveAllowedOrigins && effectiveAllowedOrigins.includes('*'))) {
+                    return res.status(403).json({ message: 'Origin header required' });
+                }
+                // Check for public access ('*') or if the request's origin is in the effective list.
+                const isAllowed = effectiveAllowedOrigins && (effectiveAllowedOrigins.includes('*') || (origin && effectiveAllowedOrigins.includes(origin)));
+                if (!isAllowed) {
+                    return res.status(403).json({ message: 'Unauthorized' });
+                }
             }
             let data;
             if (exportMetadata.nodeSchema) {

package/dist/middleware/routes/project.js

@@ -50,19 +50,19 @@ function projectRouter(config) {
             if (auth.role !== 'admin' && auth.role !== 'editor') {
                 return res.status(403).json({ message: 'Permission denied' });
             }
-            const { name, description, dbType, image, allowedOrigin } = req.body;
-            const mainDb = config.databases?.find(db => db.main);
+            const { name, description, image, allowedOrigin } = req.body;
+            const mainDb = config.databases?.find(db => db.main) ?? config.databases?.[0];
             if (!mainDb) {
-                return res.status(500).json({ message: 'Main database not configured' });
+                return res.status(500).json({ message: 'No database configured' });
             }
-            const userDbType = mainDb.type;
-            const User = (0, manager_1.getModel)('users', userDbType);
+            const dbType = mainDb.type;
+            const User = (0, manager_1.getModel)('users', dbType);
             const user = await User.findOne({ _id: auth.userId });
             if (!user) {
                 return res.status(404).json({ message: 'User not found' });
             }
             const newProject = await Project.create({
-                dbType: dbType || 'nosql',
+                dbType,
                 name,
                 description: description || '',
                 image: image || '',

package/dist/middleware/routes/storage.js

@@ -8,9 +8,11 @@ const express_1 = require("express");
 const file_1 = require("../../services/file");
 const presign_1 = require("../../services/presign");
 const storage_1 = require("../../providers/storage");
+const s3_1 = require("../../adapters/storage/s3");
 const manager_1 = require("../../models/manager");
 const connectionManager_1 = require("../../adapters/database/connectionManager");
 const auth_1 = require("../../utils/auth");
+const encryption_1 = require("../../utils/encryption");
 const mongodb_1 = require("mongodb");
 const crypto_1 = __importDefault(require("crypto"));
 const VALID_CATEGORIES = ['images', 'audios', 'videos', '3d-models'];
@@ -36,6 +38,32 @@ function getRawFilesCollection() {
         return null;
     return (0, connectionManager_1.getConnection)(activeId).client.db().collection('storage_files');
 }
+function connFilter(projectId, connId, extra) {
+    const isBuiltin = connId === 'builtin' || connId.startsWith('builtin-');
+    const connMatch = isBuiltin
+        ? { $or: [{ storageConnectionId: connId }, { storageConnectionId: { $exists: false } }] }
+        : { storageConnectionId: connId };
+    return { projectId, ...connMatch, ...(extra ?? {}) };
+}
+async function resolveConnAdapter(connId, project, globalAdapter) {
+    if (connId === 'builtin' || connId.startsWith('builtin-'))
+        return globalAdapter;
+    const conn = project.storageConnections?.find((c) => c.id === connId);
+    if (!conn)
+        return { error: 'Storage connection not found', status: 404 };
+    if (!(0, encryption_1.isEncryptionKeySet)())
+        return { error: 'Encryption key not set', status: 500 };
+    const credential = project.credentials?.find((c) => c.id === conn.credentialId);
+    if (!credential)
+        return { error: 'Credential not found in project', status: 400 };
+    try {
+        const s3Config = JSON.parse((0, encryption_1.decrypt)(credential.encryptedValue));
+        return new s3_1.S3Adapter(s3Config);
+    }
+    catch (e) {
+        return { error: `Failed to initialize storage adapter: ${e.message}`, status: 500 };
+    }
+}
 function storageRouter(config) {
     const router = (0, express_1.Router)();
     const adapter = config.adapter || (0, storage_1.createStorageProvider)(config.storageProviders);
@@ -212,6 +240,157 @@ function storageRouter(config) {
             res.status(500).json({ message: 'Failed to list files', details: err.message });
         }
     });
+    // ─── Per-connection file routes ───────────────────────────────────────────
+    router.get('/projects/:projectId/connections/storage/:connId/upload-url', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId, connId } = req.params;
+            const { fileName, contentType, category } = req.query;
+            if (!category || !VALID_CATEGORIES.includes(category)) {
+                return res.status(400).json({ message: `Invalid category. Must be one of: ${VALID_CATEGORIES.join(', ')}` });
+            }
+            if (!fileName || !contentType) {
+                return res.status(400).json({ message: 'Query params fileName and contentType are required' });
+            }
+            if (!validateContentType(contentType, fileName, category)) {
+                return res.status(400).json({ message: `File does not match category ${category}` });
+            }
+            const project = await Project.findOne({ _id: projectId });
+            if (!project)
+                return res.status(404).json({ message: 'Project not found' });
+            if (!(0, auth_1.isProjectMember)(project, auth.userId))
+                return res.status(403).json({ message: 'Unauthorized access' });
+            const connAdapter = await resolveConnAdapter(connId, project, adapter);
+            if ('error' in connAdapter)
+                return res.status(connAdapter.status).json({ message: connAdapter.error });
+            if (!connAdapter.getPresignedUploadUrl)
+                return res.status(501).json({ message: 'Storage adapter does not support presigned uploads' });
+            const ext = fileName.includes('.') ? `.${fileName.split('.').pop().toLowerCase()}` : '';
+            const fileId = crypto_1.default.randomUUID();
+            const storageKey = `${projectId}/${category}/${fileId}${ext}`;
+            const collection = getRawFilesCollection();
+            if (collection) {
+                await collection.insertOne({
+                    _id: new mongodb_1.ObjectId(),
+                    fileId,
+                    projectId,
+                    storageConnectionId: connId,
+                    category,
+                    storageKey,
+                    displayName: fileName,
+                    contentType,
+                    uploadedBy: auth.userId,
+                    createdAt: new Date(),
+                });
+            }
+            const url = await connAdapter.getPresignedUploadUrl(storageKey, contentType);
+            res.json({ url, fileId, storageKey, displayName: fileName });
+        }
+        catch (err) {
+            res.status(500).json({ message: 'Failed to generate upload URL', details: err.message });
+        }
+    });
+    router.get('/projects/:projectId/connections/storage/:connId/files/lasts', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId, connId } = req.params;
+            const project = await Project.findOne({ _id: projectId });
+            if (!project)
+                return res.status(404).json({ message: 'Project not found' });
+            if (!(0, auth_1.isProjectMember)(project, auth.userId))
+                return res.status(403).json({ message: 'Unauthorized access' });
+            const connAdapter = await resolveConnAdapter(connId, project, adapter);
+            if ('error' in connAdapter)
+                return res.status(connAdapter.status).json({ message: connAdapter.error });
+            const collection = getRawFilesCollection();
+            if (!collection)
+                return res.status(500).json({ message: 'Database not available' });
+            const files = await collection.find(connFilter(projectId, connId)).sort({ createdAt: -1 }).limit(12).toArray();
+            const data = await Promise.all(files.map(f => resolveFileUrl(f, connAdapter)));
+            res.json({ data });
+        }
+        catch (err) {
+            res.status(500).json({ message: 'Failed to fetch latest files', details: err.message });
+        }
+    });
+    router.get('/projects/:projectId/connections/storage/:connId/files/:category', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId, connId, category } = req.params;
+            if (!VALID_CATEGORIES.includes(category)) {
+                return res.status(400).json({ message: `Invalid category. Must be one of: ${VALID_CATEGORIES.join(', ')}` });
+            }
+            const project = await Project.findOne({ _id: projectId });
+            if (!project)
+                return res.status(404).json({ message: 'Project not found' });
+            if (!(0, auth_1.isProjectMember)(project, auth.userId))
+                return res.status(403).json({ message: 'Unauthorized access' });
+            const connAdapter = await resolveConnAdapter(connId, project, adapter);
+            if ('error' in connAdapter)
+                return res.status(connAdapter.status).json({ message: connAdapter.error });
+            const collection = getRawFilesCollection();
+            if (!collection)
+                return res.status(500).json({ message: 'Database not available' });
+            const files = await collection.find(connFilter(projectId, connId, { category })).sort({ createdAt: -1 }).toArray();
+            const data = await Promise.all(files.map(f => resolveFileUrl(f, connAdapter)));
+            res.json({ data });
+        }
+        catch (err) {
+            res.status(500).json({ message: 'Failed to list files', details: err.message });
+        }
+    });
+    router.patch('/projects/:projectId/connections/storage/:connId/files/:fileId', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId, connId, fileId } = req.params;
+            const { displayName } = req.body;
+            if (!displayName || typeof displayName !== 'string') {
+                return res.status(400).json({ message: 'displayName is required' });
+            }
+            const project = await Project.findOne({ _id: projectId });
+            if (!project)
+                return res.status(404).json({ message: 'Project not found' });
+            if (!(0, auth_1.isProjectMember)(project, auth.userId))
+                return res.status(403).json({ message: 'Unauthorized access' });
+            const collection = getRawFilesCollection();
+            if (!collection)
+                return res.status(500).json({ message: 'Database not available' });
+            const result = await collection.findOneAndUpdate(connFilter(projectId, connId, { fileId }), { $set: { displayName } }, { returnDocument: 'after' });
+            if (!result)
+                return res.status(404).json({ message: 'File not found' });
+            res.json({ message: 'File renamed successfully', file: result });
+        }
+        catch (err) {
+            res.status(500).json({ message: 'Failed to rename file', details: err.message });
+        }
+    });
+    router.delete('/projects/:projectId/connections/storage/:connId/files/:fileId', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId, connId, fileId } = req.params;
+            const project = await Project.findOne({ _id: projectId });
+            if (!project)
+                return res.status(404).json({ message: 'Project not found' });
+            if (!(0, auth_1.isProjectMember)(project, auth.userId))
+                return res.status(403).json({ message: 'Unauthorized access' });
+            const connAdapter = await resolveConnAdapter(connId, project, adapter);
+            if ('error' in connAdapter)
+                return res.status(connAdapter.status).json({ message: connAdapter.error });
+            const collection = getRawFilesCollection();
+            if (!collection)
+                return res.status(500).json({ message: 'Database not available' });
+            const fileDoc = await collection.findOne(connFilter(projectId, connId, { fileId }));
+            if (!fileDoc)
+                return res.status(404).json({ message: 'File not found' });
+            if (connAdapter.deleteFile)
+                await connAdapter.deleteFile(fileDoc.storageKey);
+            await collection.deleteOne(connFilter(projectId, connId, { fileId }));
+            res.json({ message: 'File deleted successfully' });
+        }
+        catch (err) {
+            res.status(500).json({ message: 'Failed to delete file', details: err.message });
+        }
+    });
     router.get('/storages', async (_req, res) => {
         try {
             const STORAGE_DISPLAY = {

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

@@ -0,0 +1,3 @@
+import { Router } from 'express';
+import { StreamByConfig } from '../../types';
+export declare function storageConnectionRouter(config: StreamByConfig): Router;

package/dist/middleware/routes/storageConnection.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.storageConnectionRouter = storageConnectionRouter;
+const express_1 = require("express");
+const mongodb_1 = require("mongodb");
+const manager_1 = require("../../models/manager");
+const auth_1 = require("../../utils/auth");
+const VALID_STORAGE_TYPES = ['s3', 'gcs', 'r2', 'azure'];
+const STORAGE_DISPLAY = {
+    s3: 'AWS S3',
+    gcs: 'Google Cloud Storage',
+    r2: 'Cloudflare R2',
+    azure: 'Azure Blob Storage',
+};
+function storageConnectionRouter(config) {
+    const router = (0, express_1.Router)();
+    const Project = (0, manager_1.getModel)('projects');
+    // ─── List storage connections ─────────────────────────────────────────────
+    router.get('/projects/:id/connections/storage', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const project = await Project.findOne({ _id: req.params.id });
+            if (!project)
+                return res.status(404).json({ message: 'Project not found' });
+            if (!(0, auth_1.isProjectMember)(project, auth.userId))
+                return res.status(403).json({ message: 'Unauthorized project access' });
+            const builtinConnections = (config.storageProviders || []).map((provider, i) => ({
+                id: i === 0 ? 'builtin' : `builtin-${i}`,
+                name: STORAGE_DISPLAY[provider.type] || provider.type,
+                type: provider.type,
+                credentialId: '',
+                projectId: req.params.id,
+                createdAt: new Date(0),
+                isBuiltin: true,
+            }));
+            const projectConnections = project.storageConnections || [];
+            return res.status(200).json({ data: [...builtinConnections, ...projectConnections] });
+        }
+        catch (err) {
+            res.status(500).json({ message: 'Failed to fetch storage connections', details: err.message });
+        }
+    });
+    // ─── Add storage connection ───────────────────────────────────────────────
+    router.post('/projects/:id/connections/storage', async (req, res) => {
+        try {
+            const auth = req.auth;
+            if (auth.role !== 'admin' && auth.role !== 'editor') {
+                return res.status(403).json({ message: 'Permission denied' });
+            }
+            const { name, type, credentialId, description } = req.body;
+            if (!name || !type || !credentialId) {
+                return res.status(400).json({ message: 'name, type, and credentialId are required' });
+            }
+            if (!VALID_STORAGE_TYPES.includes(type)) {
+                return res.status(400).json({ message: `type must be one of: ${VALID_STORAGE_TYPES.join(', ')}` });
+            }
+            const project = await Project.findOne({ _id: req.params.id });
+            if (!project)
+                return res.status(404).json({ message: 'Project not found' });
+            if (!(0, auth_1.isProjectMember)(project, auth.userId))
+                return res.status(403).json({ message: 'Unauthorized project access' });
+            const credExists = project.credentials?.some((c) => c.id === credentialId);
+            if (!credExists)
+                return res.status(400).json({ message: 'Credential not found in project' });
+            const connection = {
+                id: new mongodb_1.ObjectId().toHexString(),
+                name,
+                type,
+                credentialId,
+                projectId: req.params.id,
+                createdAt: new Date(),
+                ...(description !== undefined && { description }),
+            };
+            await Project.update({ _id: req.params.id }, { $push: { storageConnections: connection } });
+            return res.status(201).json({ data: connection });
+        }
+        catch (err) {
+            res.status(500).json({ message: 'Failed to add storage connection', details: err.message });
+        }
+    });
+    // ─── Delete storage connection ────────────────────────────────────────────
+    router.delete('/projects/:id/connections/storage/:connId', async (req, res) => {
+        try {
+            const { connId } = req.params;
+            if (connId === 'builtin' || connId.startsWith('builtin-')) {
+                return res.status(403).json({ message: 'Cannot delete a built-in storage connection' });
+            }
+            const auth = req.auth;
+            if (auth.role !== 'admin' && auth.role !== 'editor') {
+                return res.status(403).json({ message: 'Permission denied' });
+            }
+            const project = await Project.findOne({ _id: req.params.id });
+            if (!project)
+                return res.status(404).json({ message: 'Project not found' });
+            if (!(0, auth_1.isProjectMember)(project, auth.userId))
+                return res.status(403).json({ message: 'Unauthorized project access' });
+            const exists = project.storageConnections?.some((c) => c.id === connId);
+            if (!exists)
+                return res.status(404).json({ message: 'Storage connection not found' });
+            await Project.update({ _id: req.params.id }, { $pull: { storageConnections: { id: connId } } });
+            return res.status(200).json({ message: 'Storage connection deleted successfully' });
+        }
+        catch (err) {
+            res.status(500).json({ message: 'Failed to delete storage connection', details: err.message });
+        }
+    });
+    return router;
+}

package/dist/models/Model.d.ts

@@ -11,6 +11,7 @@ export declare class Model<T extends Document> {
     private transformResult;
     findOne(filter: any): Promise<T | null>;
     create(data: T): Promise<T>;
+    private updateSqlJsonbArray;
     update(filter: any, data: Partial<T>): Promise<T | null>;
     delete(filter: any): Promise<number>;
 }

package/dist/models/Model.js

@@ -45,19 +45,20 @@ class Model {
                     // Handle members filter for SQL projects
                     const userId = processedFilter.members.$elemMatch.userId;
                     const schema = this.schema || 'streamby'; // Default to 'streamby' if schema not provided
-                    const query = `
-            SELECT p.*, pm."userId" as memberUserId, pm.archived as memberArchived
-            FROM "${schema}"."projects" p
-            JOIN "${schema}"."project_members" pm ON p.id = pm."projectId"
-            WHERE pm."userId" = $1
+                    const query = `
+            SELECT p.*, pm."userId" as memberUserId, pm.role as memberRole, pm.status as memberStatus, pm.archived as memberArchived
+            FROM "${schema}"."projects" p
+            JOIN "${schema}"."project_members" pm ON p.id = pm."projectId"
+            WHERE pm."userId" = $1
           `;
                     const result = await connection.query(query, [userId]);
                     sqlResults = result.rows.map(row => ({
                         ...row,
                         members: [{
                                 userId: row.memberUserId,
+                                role: row.memberRole,
+                                status: row.memberStatus,
                                 archived: row.memberArchived,
-                                // Add other member fields if necessary
                             }]
                     }));
                 }
@@ -72,7 +73,8 @@ class Model {
                         const projectMembers = await sql_1.sqlAdapter.find(connection, 'project_members', { projectId: transformedItem.id }, this.schema);
                         transformedItem.members = projectMembers.map((member) => ({
                             userId: member.userId,
-                            role: member.role, // Assuming role is also stored in project_members
+                            role: member.role,
+                            status: member.status,
                             archived: member.archived,
                         }));
                     }
@@ -122,7 +124,8 @@ class Model {
                         const projectMembers = await sql_1.sqlAdapter.find(connection, 'project_members', { projectId: transformedResult.id }, this.schema);
                         transformedResult.members = projectMembers.map((member) => ({
                             userId: member.userId,
-                            role: member.role, // Assuming role is also stored in project_members
+                            role: member.role,
+                            status: member.status,
                             archived: member.archived,
                         }));
                     }
@@ -195,6 +198,22 @@ class Model {
         }
         return data;
     }
+    async updateSqlJsonbArray(connection, id, op, field, value) {
+        const schema = this.schema || 'streamby';
+        const tbl = `"${schema}"."${this.tableName}"`;
+        if (op === '$push') {
+            await connection.query(`UPDATE ${tbl} SET "${field}" = "${field}" || $1::jsonb WHERE id = $2`, [JSON.stringify([value]), id]);
+        }
+        else {
+            const matchKey = value.id !== undefined ? 'id' : Object.keys(value)[0];
+            const matchVal = String(value[matchKey]);
+            await connection.query(`UPDATE ${tbl} SET "${field}" = (
+          SELECT COALESCE(jsonb_agg(elem), '[]'::jsonb)
+          FROM jsonb_array_elements("${field}") elem
+          WHERE elem->>'${matchKey}' != $1
+        ) WHERE id = $2`, [matchVal, id]);
+        }
+    }
     async update(filter, data) {
         const existingProject = await this.findOne(filter); // Find the project first
         if (!existingProject) {
@@ -270,8 +289,15 @@ class Model {
         }
         else {
             // General update logic
-            // Use the correctly constructed updateFilter
             if (dbType === 'sql') {
+                // Detect MongoDB-style array operators ($push / $pull) and map to JSONB operations
+                const op = Object.keys(data).find(k => k === '$push' || k === '$pull');
+                if (op) {
+                    const field = Object.keys(data[op])[0];
+                    const value = data[op][field];
+                    await this.updateSqlJsonbArray(connection, existingProject.id, op, field, value);
+                    return await this.findOne({ _id: existingProject.id });
+                }
                 const result = await sql_1.sqlAdapter.update(connection, this.tableName, updateFilter, data, this.schema);
                 if (result)
                     return result;

package/dist/services/dbConnection.d.ts

@@ -0,0 +1,18 @@
+import { Pool } from 'pg';
+import { MongoClient } from 'mongodb';
+import { ExternalDbType, CreateTableSchema } from '../types';
+export declare function listTablesOrCollections(connectionString: string, dbType: ExternalDbType): Promise<string[]>;
+export declare function createTableOrCollection(connectionString: string, dbType: ExternalDbType, schema: CreateTableSchema): Promise<void>;
+export declare function queryRecords(connectionString: string, dbType: ExternalDbType, tableName: string, limit?: number, offset?: number): Promise<any[]>;
+export declare function insertRecord(connectionString: string, dbType: ExternalDbType, tableName: string, record: Record<string, unknown>): Promise<any>;
+export declare function updateRecord(connectionString: string, dbType: ExternalDbType, tableName: string, recordId: string, updates: Record<string, unknown>): Promise<any | null>;
+export declare function deleteRecord(connectionString: string, dbType: ExternalDbType, tableName: string, recordId: string): Promise<boolean>;
+export declare function listTablesInternal(client: Pool | MongoClient, dbType: 'sql' | 'nosql', projectId?: string): Promise<string[]>;
+export declare function queryRecordsInternal(client: Pool | MongoClient, dbType: 'sql' | 'nosql', tableName: string, limit?: number, offset?: number, projectId?: string): Promise<any[]>;
+export declare function queryRecordByIdInternal(client: Pool | MongoClient, dbType: 'sql' | 'nosql', tableName: string, recordId: string, projectId?: string): Promise<any | null>;
+export declare function createTableOrCollectionInternal(client: Pool | MongoClient, dbType: 'sql' | 'nosql', schema: CreateTableSchema, projectId?: string): Promise<void>;
+export declare function insertRecordInternal(client: Pool | MongoClient, dbType: 'sql' | 'nosql', tableName: string, record: Record<string, unknown>, projectId?: string): Promise<any>;
+export declare function updateRecordInternal(client: Pool | MongoClient, dbType: 'sql' | 'nosql', tableName: string, recordId: string, updates: Record<string, unknown>, projectId?: string): Promise<any | null>;
+export declare function deleteRecordInternal(client: Pool | MongoClient, dbType: 'sql' | 'nosql', tableName: string, recordId: string, projectId?: string): Promise<boolean>;
+export declare function deleteTableOrCollection(connectionString: string, dbType: ExternalDbType, tableName: string): Promise<void>;
+export declare function deleteTableOrCollectionInternal(client: Pool | MongoClient, dbType: 'sql' | 'nosql', tableName: string, projectId?: string): Promise<void>;