streamby-core 0.31.0 → 0.32.1

package/dist/adapters/database/connectionManager.js

@@ -43,103 +43,108 @@ const getConnection = (id) => {
 exports.getConnection = getConnection;
 const ensureTablesExist = async (pool) => {
     try {
-        await pool.query(`
-      CREATE SCHEMA IF NOT EXISTS streamby;
-      CREATE EXTENSION IF NOT EXISTS "uuid-ossp";
+        await pool.query(`
+      CREATE SCHEMA IF NOT EXISTS streamby;
+      CREATE EXTENSION IF NOT EXISTS "uuid-ossp";
     `);
         // Migrate id column from UUID to TEXT if it was created with the old schema
-        await pool.query(`
-      DO $$ BEGIN
-        ALTER TABLE streamby.projects ALTER COLUMN id TYPE TEXT USING id::text;
-        ALTER TABLE streamby.projects ALTER COLUMN id SET DEFAULT uuid_generate_v4()::text;
-      EXCEPTION WHEN OTHERS THEN NULL; END $$;
+        await pool.query(`
+      DO $$ BEGIN
+        ALTER TABLE streamby.projects ALTER COLUMN id TYPE TEXT USING id::text;
+        ALTER TABLE streamby.projects ALTER COLUMN id SET DEFAULT uuid_generate_v4()::text;
+      EXCEPTION WHEN OTHERS THEN NULL; END $$;
     `);
-        await pool.query(`
-      CREATE TABLE IF NOT EXISTS streamby.projects (
-        id               TEXT PRIMARY KEY DEFAULT uuid_generate_v4()::text,
-        name             VARCHAR(255) NOT NULL,
-        description      TEXT,
-        image            TEXT,
-        "allowedOrigin"  JSONB DEFAULT '[]',
-        exports          JSONB DEFAULT '[]',
-        connections      JSONB DEFAULT '[]',
-        "dbConnections"  JSONB DEFAULT '[]',
-        "dbType"         VARCHAR(50) NOT NULL DEFAULT 'sql',
-        "createdAt"      TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
-        "updatedAt"      TIMESTAMP WITH TIME ZONE DEFAULT NOW()
-      );
+        await pool.query(`
+      CREATE TABLE IF NOT EXISTS streamby.projects (
+        id               TEXT PRIMARY KEY DEFAULT uuid_generate_v4()::text,
+        name             VARCHAR(255) NOT NULL,
+        description      TEXT,
+        image            TEXT,
+        "allowedOrigin"  JSONB DEFAULT '[]',
+        exports          JSONB DEFAULT '[]',
+        connections      JSONB DEFAULT '[]',
+        "dbConnections"  JSONB DEFAULT '[]',
+        "dbType"         VARCHAR(50) NOT NULL DEFAULT 'sql',
+        "createdAt"      TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
+        "updatedAt"      TIMESTAMP WITH TIME ZONE DEFAULT NOW()
+      );
     `);
         console.log('✅ "projects" table ensured to exist.');
         // Add JSONB columns to existing tables that predate this schema version
-        await pool.query(`
-      ALTER TABLE streamby.projects ADD COLUMN IF NOT EXISTS "allowedOrigin"     JSONB DEFAULT '[]';
-      ALTER TABLE streamby.projects ADD COLUMN IF NOT EXISTS exports             JSONB DEFAULT '[]';
-      ALTER TABLE streamby.projects ADD COLUMN IF NOT EXISTS connections         JSONB DEFAULT '[]';
-      ALTER TABLE streamby.projects ADD COLUMN IF NOT EXISTS "dbConnections"     JSONB DEFAULT '[]';
-      ALTER TABLE streamby.projects ADD COLUMN IF NOT EXISTS "storageConnections" JSONB DEFAULT '[]';
-      ALTER TABLE streamby.projects ADD COLUMN IF NOT EXISTS workflow            JSONB;
-      ALTER TABLE streamby.projects ADD COLUMN IF NOT EXISTS pipelines           JSONB DEFAULT '[]';
-      ALTER TABLE streamby.projects ADD COLUMN IF NOT EXISTS "builtinBackfilledAt" TIMESTAMP WITH TIME ZONE;
+        await pool.query(`
+      ALTER TABLE streamby.projects ADD COLUMN IF NOT EXISTS "allowedOrigin"     JSONB DEFAULT '[]';
+      ALTER TABLE streamby.projects ADD COLUMN IF NOT EXISTS exports             JSONB DEFAULT '[]';
+      ALTER TABLE streamby.projects ADD COLUMN IF NOT EXISTS connections         JSONB DEFAULT '[]';
+      ALTER TABLE streamby.projects ADD COLUMN IF NOT EXISTS "dbConnections"     JSONB DEFAULT '[]';
+      ALTER TABLE streamby.projects ADD COLUMN IF NOT EXISTS "storageConnections" JSONB DEFAULT '[]';
+      ALTER TABLE streamby.projects ADD COLUMN IF NOT EXISTS workflow            JSONB;
+      ALTER TABLE streamby.projects ADD COLUMN IF NOT EXISTS pipelines           JSONB DEFAULT '[]';
+      ALTER TABLE streamby.projects ADD COLUMN IF NOT EXISTS "builtinBackfilledAt" TIMESTAMP WITH TIME ZONE;
+      -- Reverted: a project has no notion of a "default" database/storage connection —
+      -- each dataSourceNode/ingestNode always declares its own connection explicitly.
+      ALTER TABLE streamby.projects DROP COLUMN IF EXISTS "defaultDatabaseId";
+      ALTER TABLE streamby.projects DROP COLUMN IF EXISTS "defaultStorageId";
+      ALTER TABLE streamby.projects DROP COLUMN IF EXISTS "defaultConnectionsBackfilledAt";
     `);
         // Ensure dbType exists with a non-null default
-        await pool.query(`
-      ALTER TABLE streamby.projects ADD COLUMN IF NOT EXISTS "dbType" VARCHAR(50) NOT NULL DEFAULT 'sql';
+        await pool.query(`
+      ALTER TABLE streamby.projects ADD COLUMN IF NOT EXISTS "dbType" VARCHAR(50) NOT NULL DEFAULT 'sql';
     `);
-        await pool.query(`
-      CREATE TABLE IF NOT EXISTS streamby.project_members (
-        id           TEXT PRIMARY KEY DEFAULT uuid_generate_v4()::text,
-        "projectId"  TEXT NOT NULL REFERENCES streamby.projects(id) ON DELETE CASCADE,
-        "userId"     VARCHAR(255) NOT NULL,
-        role         VARCHAR(255) NOT NULL DEFAULT 'member',
-        status       VARCHAR(50) NOT NULL DEFAULT 'active',
-        archived     BOOLEAN NOT NULL DEFAULT FALSE,
-        "archivedBy" VARCHAR(255),
-        "archivedAt" TIMESTAMP WITH TIME ZONE,
-        "createdAt"  TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
-        "updatedAt"  TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
-        UNIQUE ("projectId", "userId")
-      );
+        await pool.query(`
+      CREATE TABLE IF NOT EXISTS streamby.project_members (
+        id           TEXT PRIMARY KEY DEFAULT uuid_generate_v4()::text,
+        "projectId"  TEXT NOT NULL REFERENCES streamby.projects(id) ON DELETE CASCADE,
+        "userId"     VARCHAR(255) NOT NULL,
+        role         VARCHAR(255) NOT NULL DEFAULT 'member',
+        status       VARCHAR(50) NOT NULL DEFAULT 'active',
+        archived     BOOLEAN NOT NULL DEFAULT FALSE,
+        "archivedBy" VARCHAR(255),
+        "archivedAt" TIMESTAMP WITH TIME ZONE,
+        "createdAt"  TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
+        "updatedAt"  TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
+        UNIQUE ("projectId", "userId")
+      );
     `);
-        await pool.query(`
-      ALTER TABLE streamby.project_members ADD COLUMN IF NOT EXISTS status VARCHAR(50) NOT NULL DEFAULT 'active';
+        await pool.query(`
+      ALTER TABLE streamby.project_members ADD COLUMN IF NOT EXISTS status VARCHAR(50) NOT NULL DEFAULT 'active';
     `);
         console.log('✅ "project_members" table ensured to exist.');
         // Migrate projectId FK column from UUID to TEXT if table predates this schema version
-        await pool.query(`
-      DO $$ BEGIN
-        ALTER TABLE streamby.project_members DROP CONSTRAINT IF EXISTS project_members_projectId_fkey;
-        ALTER TABLE streamby.project_members ALTER COLUMN "projectId" TYPE TEXT;
-        ALTER TABLE streamby.project_members ADD CONSTRAINT project_members_projectid_fkey
-          FOREIGN KEY ("projectId") REFERENCES streamby.projects(id) ON DELETE CASCADE;
-      EXCEPTION WHEN OTHERS THEN NULL; END $$;
+        await pool.query(`
+      DO $$ BEGIN
+        ALTER TABLE streamby.project_members DROP CONSTRAINT IF EXISTS project_members_projectId_fkey;
+        ALTER TABLE streamby.project_members ALTER COLUMN "projectId" TYPE TEXT;
+        ALTER TABLE streamby.project_members ADD CONSTRAINT project_members_projectid_fkey
+          FOREIGN KEY ("projectId") REFERENCES streamby.projects(id) ON DELETE CASCADE;
+      EXCEPTION WHEN OTHERS THEN NULL; END $$;
     `);
-        await pool.query(`
-      CREATE TABLE IF NOT EXISTS streamby.exports (
-        id          TEXT PRIMARY KEY DEFAULT uuid_generate_v4()::text,
-        "projectId" TEXT NOT NULL REFERENCES streamby.projects(id) ON DELETE CASCADE,
-        status      VARCHAR(50) NOT NULL DEFAULT 'pending',
-        "filePath"  TEXT,
-        "createdAt" TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
-        "updatedAt" TIMESTAMP WITH TIME ZONE DEFAULT NOW()
-      );
+        await pool.query(`
+      CREATE TABLE IF NOT EXISTS streamby.exports (
+        id          TEXT PRIMARY KEY DEFAULT uuid_generate_v4()::text,
+        "projectId" TEXT NOT NULL REFERENCES streamby.projects(id) ON DELETE CASCADE,
+        status      VARCHAR(50) NOT NULL DEFAULT 'pending',
+        "filePath"  TEXT,
+        "createdAt" TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
+        "updatedAt" TIMESTAMP WITH TIME ZONE DEFAULT NOW()
+      );
     `);
         console.log('✅ "exports" table ensured to exist.');
         // user_integrations is registered against the main db only (see createRouter.ts), but
         // this function runs per-SQL-connection like projects/exports above — harmless on
         // non-main connections since the model never queries them there.
-        await pool.query(`
-      CREATE TABLE IF NOT EXISTS streamby.user_integrations (
-        id                     TEXT PRIMARY KEY DEFAULT uuid_generate_v4()::text,
-        "userId"               VARCHAR(255) NOT NULL,
-        kind                   VARCHAR(20) NOT NULL,
-        provider               VARCHAR(20) NOT NULL,
-        name                   VARCHAR(255) NOT NULL,
-        description            TEXT,
-        "encryptedCredential"  TEXT NOT NULL,
-        "createdAt"            TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
-        "updatedAt"            TIMESTAMP WITH TIME ZONE DEFAULT NOW()
-      );
-      CREATE INDEX IF NOT EXISTS user_integrations_userid_idx ON streamby.user_integrations ("userId");
+        await pool.query(`
+      CREATE TABLE IF NOT EXISTS streamby.user_integrations (
+        id                     TEXT PRIMARY KEY DEFAULT uuid_generate_v4()::text,
+        "userId"               VARCHAR(255) NOT NULL,
+        kind                   VARCHAR(20) NOT NULL,
+        provider               VARCHAR(20) NOT NULL,
+        name                   VARCHAR(255) NOT NULL,
+        description            TEXT,
+        "encryptedCredential"  TEXT NOT NULL,
+        "createdAt"            TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
+        "updatedAt"            TIMESTAMP WITH TIME ZONE DEFAULT NOW()
+      );
+      CREATE INDEX IF NOT EXISTS user_integrations_userid_idx ON streamby.user_integrations ("userId");
     `);
         console.log('✅ "user_integrations" table ensured to exist.');
     }

package/dist/adapters/database/sql.js

@@ -10,7 +10,7 @@ function serializeForPg(v) {
 }
 const createSQLExportTable = async (connection, projectId, exportName, nodeSchema) => {
     const exportId = (0, crypto_1.randomUUID)();
-    await connection.query(`INSERT INTO "exports" (id, "projectId", node_schema, name, method, created_at, updated_at)
+    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 };
 };

package/dist/middleware/routes/dbConnection.js

@@ -1,88 +1,31 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.dbConnectionRouter = dbConnectionRouter;
 const express_1 = require("express");
 const mongodb_1 = require("mongodb");
 const manager_1 = require("../../models/manager");
 const auth_1 = require("../../utils/auth");
-const connectionManager_1 = require("../../adapters/database/connectionManager");
-const builtinAccess_1 = require("../../utils/builtinAccess");
-const userIntegration_1 = require("../../services/userIntegration");
 const sanitize_1 = require("../../utils/sanitize");
 const encryption_1 = require("../../utils/encryption");
+const connectionResolver_1 = require("../../services/connectionResolver");
 const dbConnection_1 = require("../../services/dbConnection");
 const VALID_DB_TYPES = ['postgresql', 'mongodb'];
-// `builtinId` is config.databases[].id (e.g. 'mongo'), NOT the DbConnection row's own id —
-// those are different values since TCORE-69's backfill gives each row its own UUID.
-function resolveBuiltinConnection(builtinId, config) {
-    const db = (config.databases ?? []).find(d => d.id === builtinId);
-    if (!db)
-        return { error: `Database '${builtinId}' not found in config`, status: 404 };
-    try {
-        const { client, type } = (0, connectionManager_1.getConnection)(builtinId);
-        return { client: client, dbType: type };
+// Resolves the client for `connId`, runs `fn`, and writes the response — releasing
+// ephemeral (non-builtin) clients afterward. Builtin clients are pooled and owned by
+// connectionManager, never closed here. Responds with the resolve error directly if
+// resolution fails, so callers never have to distinguish an error shape from fn's result.
+async function withResolvedDbClient(project, connId, config, auth, res, fn) {
+    const resolved = await (0, connectionResolver_1.resolveDbConnectionClient)(project, connId, config, auth);
+    if ('error' in resolved) {
+        res.status(resolved.status).json({ message: resolved.error });
+        return;
     }
-    catch (e) {
-        return { error: e.message, status: 503 };
+    try {
+        await fn(resolved);
     }
-}
-// Finds the connection row + classifies it. A row is builtin iff conn.source === 'builtin'
-// (persisted at creation/backfill time) — NOT by comparing the row's own id against
-// config.databases, which no longer holds since builtin rows get their own generated id.
-function findDbConnection(project, connId) {
-    return project.dbConnections?.find((c) => c.id === connId);
-}
-async function getDecryptedConnectionString(project, connId) {
-    const conn = project.dbConnections?.find((c) => c.id === connId);
-    if (!conn)
-        return { error: 'DB connection not found', status: 404 };
-    if (conn.source === 'integration') {
-        if (!conn.integrationId)
-            return { error: 'Connection is missing its integrationId', status: 500 };
-        const credential = await (0, userIntegration_1.getDecryptedIntegrationCredentialById)(conn.integrationId);
-        if (!credential)
-            return { error: 'Integration not found', status: 400 };
-        return { connectionString: credential, conn };
+    finally {
+        await (0, connectionResolver_1.releaseDbClient)(resolved);
     }
-    const { decrypt, isEncryptionKeySet } = await Promise.resolve().then(() => __importStar(require('../../utils/encryption')));
-    if (!isEncryptionKeySet())
-        return { error: 'Encryption key is not set', status: 500 };
-    if (!conn.encryptedCredential)
-        return { error: 'Connection has no stored credential', status: 400 };
-    return { connectionString: decrypt(conn.encryptedCredential), conn };
 }
 function dbConnectionRouter(config) {
     const router = (0, express_1.Router)();
@@ -171,7 +114,7 @@ function dbConnectionRouter(config) {
                 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 conn = findDbConnection(project, req.params.connId);
+            const conn = (0, connectionResolver_1.findDbConnection)(project, req.params.connId);
             if (!conn)
                 return res.status(404).json({ message: 'DB connection not found' });
             if (conn.source === 'builtin') {
@@ -193,25 +136,10 @@ function dbConnectionRouter(config) {
                 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 conn = findDbConnection(project, req.params.connId);
-            if (!conn)
-                return res.status(404).json({ message: 'DB connection not found' });
-            if (conn.source === 'builtin') {
-                const builtinId = conn.integrationId;
-                if (!(await (0, builtinAccess_1.assertBuiltinAccess)(auth, builtinId, config, 'database'))) {
-                    return res.status(403).json({ message: 'Access to this built-in database is not permitted' });
-                }
-                const internal = resolveBuiltinConnection(builtinId, config);
-                if ('error' in internal)
-                    return res.status(internal.status).json({ message: internal.error });
-                const tables = await (0, dbConnection_1.listTablesInternal)(internal.client, internal.dbType, req.params.id);
-                return res.status(200).json({ data: tables });
-            }
-            const resolved = await getDecryptedConnectionString(project, req.params.connId);
-            if ('error' in resolved)
-                return res.status(resolved.status).json({ message: resolved.error });
-            const tables = await (0, dbConnection_1.listTablesOrCollections)(resolved.connectionString, resolved.conn.dbType);
-            return res.status(200).json({ data: tables });
+            await withResolvedDbClient(project, req.params.connId, config, auth, res, async (resolved) => {
+                const tables = await (0, dbConnection_1.listTablesInternal)(resolved.client, resolved.type, req.params.id);
+                res.status(200).json({ data: tables });
+            });
         }
         catch (err) {
             res.status(500).json({ message: 'Failed to list tables', details: err.message });
@@ -232,31 +160,14 @@ function dbConnectionRouter(config) {
             const schema = req.body;
             if (!schema.tableName)
                 return res.status(400).json({ message: 'tableName is required' });
-            const conn = findDbConnection(project, req.params.connId);
-            if (!conn)
-                return res.status(404).json({ message: 'DB connection not found' });
-            if (conn.source === 'builtin') {
-                const builtinId = conn.integrationId;
-                if (!(await (0, builtinAccess_1.assertBuiltinAccess)(auth, builtinId, config, 'database'))) {
-                    return res.status(403).json({ message: 'Access to this built-in database is not permitted' });
-                }
-                const internal = resolveBuiltinConnection(builtinId, config);
-                if ('error' in internal)
-                    return res.status(internal.status).json({ message: internal.error });
-                if (internal.dbType === 'sql' && (!Array.isArray(schema.columns) || schema.columns.length === 0)) {
-                    return res.status(400).json({ message: 'columns are required for SQL tables' });
+            await withResolvedDbClient(project, req.params.connId, config, auth, res, async (resolved) => {
+                if (resolved.type === 'sql' && (!Array.isArray(schema.columns) || schema.columns.length === 0)) {
+                    res.status(400).json({ message: 'columns are required for SQL tables' });
+                    return;
                 }
-                await (0, dbConnection_1.createTableOrCollectionInternal)(internal.client, internal.dbType, schema, req.params.id);
-                return res.status(201).json({ message: `${internal.dbType === 'sql' ? 'Table' : 'Collection'} created successfully` });
-            }
-            const resolved = await getDecryptedConnectionString(project, req.params.connId);
-            if ('error' in resolved)
-                return res.status(resolved.status).json({ message: resolved.error });
-            if (resolved.conn.dbType === 'postgresql' && (!Array.isArray(schema.columns) || schema.columns.length === 0)) {
-                return res.status(400).json({ message: 'columns are required for PostgreSQL tables' });
-            }
-            await (0, dbConnection_1.createTableOrCollection)(resolved.connectionString, resolved.conn.dbType, schema);
-            return res.status(201).json({ message: `${resolved.conn.dbType === 'postgresql' ? 'Table' : 'Collection'} created successfully` });
+                await (0, dbConnection_1.createTableOrCollectionInternal)(resolved.client, resolved.type, schema, req.params.id);
+                res.status(201).json({ message: `${resolved.type === 'sql' ? 'Table' : 'Collection'} created successfully` });
+            });
         }
         catch (err) {
             res.status(500).json({ message: 'Failed to create table/collection', details: err.message });
@@ -274,25 +185,10 @@ function dbConnectionRouter(config) {
                 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 conn = findDbConnection(project, req.params.connId);
-            if (!conn)
-                return res.status(404).json({ message: 'DB connection not found' });
-            if (conn.source === 'builtin') {
-                const builtinId = conn.integrationId;
-                if (!(await (0, builtinAccess_1.assertBuiltinAccess)(auth, builtinId, config, 'database'))) {
-                    return res.status(403).json({ message: 'Access to this built-in database is not permitted' });
-                }
-                const internal = resolveBuiltinConnection(builtinId, config);
-                if ('error' in internal)
-                    return res.status(internal.status).json({ message: internal.error });
-                await (0, dbConnection_1.deleteTableOrCollectionInternal)(internal.client, internal.dbType, req.params.tableName, req.params.id);
-                return res.status(200).json({ message: 'Table/collection deleted' });
-            }
-            const resolved = await getDecryptedConnectionString(project, req.params.connId);
-            if ('error' in resolved)
-                return res.status(resolved.status).json({ message: resolved.error });
-            await (0, dbConnection_1.deleteTableOrCollection)(resolved.connectionString, resolved.conn.dbType, req.params.tableName);
-            return res.status(200).json({ message: 'Table/collection deleted' });
+            await withResolvedDbClient(project, req.params.connId, config, auth, res, async (resolved) => {
+                await (0, dbConnection_1.deleteTableOrCollectionInternal)(resolved.client, resolved.type, req.params.tableName, req.params.id);
+                res.status(200).json({ message: 'Table/collection deleted' });
+            });
         }
         catch (err) {
             res.status(500).json({ message: 'Failed to delete table/collection', details: err.message });
@@ -309,25 +205,10 @@ function dbConnectionRouter(config) {
                 return res.status(403).json({ message: 'Unauthorized project access' });
             const limit = Math.min(parseInt(String(req.query.limit ?? 50), 10), 500);
             const offset = Math.max(parseInt(String(req.query.offset ?? 0), 10), 0);
-            const conn = findDbConnection(project, req.params.connId);
-            if (!conn)
-                return res.status(404).json({ message: 'DB connection not found' });
-            if (conn.source === 'builtin') {
-                const builtinId = conn.integrationId;
-                if (!(await (0, builtinAccess_1.assertBuiltinAccess)(auth, builtinId, config, 'database'))) {
-                    return res.status(403).json({ message: 'Access to this built-in database is not permitted' });
-                }
-                const internal = resolveBuiltinConnection(builtinId, config);
-                if ('error' in internal)
-                    return res.status(internal.status).json({ message: internal.error });
-                const records = await (0, dbConnection_1.queryRecordsInternal)(internal.client, internal.dbType, req.params.tableName, limit, offset, req.params.id);
-                return res.status(200).json({ data: records });
-            }
-            const resolved = await getDecryptedConnectionString(project, req.params.connId);
-            if ('error' in resolved)
-                return res.status(resolved.status).json({ message: resolved.error });
-            const records = await (0, dbConnection_1.queryRecords)(resolved.connectionString, resolved.conn.dbType, req.params.tableName, limit, offset);
-            return res.status(200).json({ data: records });
+            await withResolvedDbClient(project, req.params.connId, config, auth, res, async (resolved) => {
+                const records = await (0, dbConnection_1.queryRecordsInternal)(resolved.client, resolved.type, req.params.tableName, limit, offset, req.params.id);
+                res.status(200).json({ data: records });
+            });
         }
         catch (err) {
             res.status(500).json({ message: 'Failed to query records', details: err.message });
@@ -349,25 +230,10 @@ function dbConnectionRouter(config) {
             if (!record || typeof record !== 'object' || Array.isArray(record)) {
                 return res.status(400).json({ message: 'Request body must be a JSON object' });
             }
-            const conn = findDbConnection(project, req.params.connId);
-            if (!conn)
-                return res.status(404).json({ message: 'DB connection not found' });
-            if (conn.source === 'builtin') {
-                const builtinId = conn.integrationId;
-                if (!(await (0, builtinAccess_1.assertBuiltinAccess)(auth, builtinId, config, 'database'))) {
-                    return res.status(403).json({ message: 'Access to this built-in database is not permitted' });
-                }
-                const internal = resolveBuiltinConnection(builtinId, config);
-                if ('error' in internal)
-                    return res.status(internal.status).json({ message: internal.error });
-                const inserted = await (0, dbConnection_1.insertRecordInternal)(internal.client, internal.dbType, req.params.tableName, record, req.params.id);
-                return res.status(201).json({ data: inserted });
-            }
-            const resolved = await getDecryptedConnectionString(project, req.params.connId);
-            if ('error' in resolved)
-                return res.status(resolved.status).json({ message: resolved.error });
-            const inserted = await (0, dbConnection_1.insertRecord)(resolved.connectionString, resolved.conn.dbType, req.params.tableName, record);
-            return res.status(201).json({ data: inserted });
+            await withResolvedDbClient(project, req.params.connId, config, auth, res, async (resolved) => {
+                const inserted = await (0, dbConnection_1.insertRecordInternal)(resolved.client, resolved.type, req.params.tableName, record, req.params.id);
+                res.status(201).json({ data: inserted });
+            });
         }
         catch (err) {
             res.status(500).json({ message: 'Failed to insert record', details: err.message });
@@ -388,25 +254,10 @@ function dbConnectionRouter(config) {
             if (!updates || typeof updates !== 'object' || Array.isArray(updates)) {
                 return res.status(400).json({ message: 'Request body must be a JSON object' });
             }
-            const conn = findDbConnection(project, req.params.connId);
-            if (!conn)
-                return res.status(404).json({ message: 'DB connection not found' });
-            if (conn.source === 'builtin') {
-                const builtinId = conn.integrationId;
-                if (!(await (0, builtinAccess_1.assertBuiltinAccess)(auth, builtinId, config, 'database'))) {
-                    return res.status(403).json({ message: 'Access to this built-in database is not permitted' });
-                }
-                const internal = resolveBuiltinConnection(builtinId, config);
-                if ('error' in internal)
-                    return res.status(internal.status).json({ message: internal.error });
-                const updated = await (0, dbConnection_1.updateRecordInternal)(internal.client, internal.dbType, req.params.tableName, req.params.recordId, updates, req.params.id);
-                return res.status(200).json({ data: updated });
-            }
-            const resolved = await getDecryptedConnectionString(project, req.params.connId);
-            if ('error' in resolved)
-                return res.status(resolved.status).json({ message: resolved.error });
-            const updated = await (0, dbConnection_1.updateRecord)(resolved.connectionString, resolved.conn.dbType, req.params.tableName, req.params.recordId, updates);
-            return res.status(200).json({ data: updated });
+            await withResolvedDbClient(project, req.params.connId, config, auth, res, async (resolved) => {
+                const updated = await (0, dbConnection_1.updateRecordInternal)(resolved.client, resolved.type, req.params.tableName, req.params.recordId, updates, req.params.id);
+                res.status(200).json({ data: updated });
+            });
         }
         catch (err) {
             res.status(500).json({ message: 'Failed to update record', details: err.message });
@@ -423,25 +274,10 @@ function dbConnectionRouter(config) {
                 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 conn = findDbConnection(project, req.params.connId);
-            if (!conn)
-                return res.status(404).json({ message: 'DB connection not found' });
-            if (conn.source === 'builtin') {
-                const builtinId = conn.integrationId;
-                if (!(await (0, builtinAccess_1.assertBuiltinAccess)(auth, builtinId, config, 'database'))) {
-                    return res.status(403).json({ message: 'Access to this built-in database is not permitted' });
-                }
-                const internal = resolveBuiltinConnection(builtinId, config);
-                if ('error' in internal)
-                    return res.status(internal.status).json({ message: internal.error });
-                await (0, dbConnection_1.deleteRecordInternal)(internal.client, internal.dbType, req.params.tableName, req.params.recordId, req.params.id);
-                return res.status(200).json({ message: 'Record deleted' });
-            }
-            const resolved = await getDecryptedConnectionString(project, req.params.connId);
-            if ('error' in resolved)
-                return res.status(resolved.status).json({ message: resolved.error });
-            await (0, dbConnection_1.deleteRecord)(resolved.connectionString, resolved.conn.dbType, req.params.tableName, req.params.recordId);
-            return res.status(200).json({ message: 'Record deleted' });
+            await withResolvedDbClient(project, req.params.connId, config, auth, res, async (resolved) => {
+                await (0, dbConnection_1.deleteRecordInternal)(resolved.client, resolved.type, req.params.tableName, req.params.recordId, req.params.id);
+                res.status(200).json({ message: 'Record deleted' });
+            });
         }
         catch (err) {
             res.status(500).json({ message: 'Failed to delete record', details: err.message });

package/dist/middleware/routes/storage.js

@@ -8,13 +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 builtinAccess_1 = require("../../utils/builtinAccess");
-const userIntegration_1 = require("../../services/userIntegration");
+const connectionResolver_1 = require("../../services/connectionResolver");
 const mongodb_1 = require("mongodb");
 const crypto_1 = __importDefault(require("crypto"));
 const VALID_CATEGORIES = ['images', 'audios', 'videos', '3d-models'];
@@ -69,45 +67,7 @@ function storageRouter(config) {
             : { storageConnectionId: connId };
         return { projectId, ...connMatch, ...(extra ?? {}) };
     }
-    async function resolveConnAdapter(connId, project, auth) {
-        const conn = findStorageConn(project, connId);
-        if (!conn)
-            return { error: 'Storage connection not found', status: 404 };
-        if (conn.source === 'builtin') {
-            const builtinId = conn.integrationId;
-            if (!(await (0, builtinAccess_1.assertBuiltinAccess)(auth, builtinId, config, 'storage'))) {
-                return { error: 'Access to this built-in storage is not permitted', status: 403 };
-            }
-            const provider = config.storageProviders.find(p => p.id === builtinId);
-            if (!provider)
-                return { error: 'Storage provider not found', status: 404 };
-            return provider.type === 's3' ? new s3_1.S3Adapter(provider.config) : adapter;
-        }
-        if (conn.source === 'integration') {
-            if (!conn.integrationId)
-                return { error: 'Connection is missing its integrationId', status: 500 };
-            try {
-                const s3Config = await (0, userIntegration_1.getDecryptedIntegrationCredentialById)(conn.integrationId);
-                if (!s3Config)
-                    return { error: 'Integration not found', status: 400 };
-                return new s3_1.S3Adapter(s3Config);
-            }
-            catch (e) {
-                return { error: `Failed to initialize storage adapter: ${e.message}`, status: 500 };
-            }
-        }
-        if (!(0, encryption_1.isEncryptionKeySet)())
-            return { error: 'Encryption key not set', status: 500 };
-        if (!conn.encryptedCredential)
-            return { error: 'Connection has no stored credential', status: 400 };
-        try {
-            const s3Config = JSON.parse((0, encryption_1.decrypt)(conn.encryptedCredential));
-            return new s3_1.S3Adapter(s3Config);
-        }
-        catch (e) {
-            return { error: `Failed to initialize storage adapter: ${e.message}`, status: 500 };
-        }
-    }
+    const resolveConnAdapter = (connId, project, auth) => (0, connectionResolver_1.resolveStorageAdapter)(project, connId, { ...config, adapter }, auth);
     router.get('/upload-project-image-url/:id', async (req, res) => {
         try {
             const auth = req.auth;

package/dist/models/Model.js

@@ -45,11 +45,11 @@ 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.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 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 => ({
@@ -219,10 +219,10 @@ class Model {
         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
+            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]);
         }
     }