streamby-core 0.38.0 → 0.39.0

package/dist/adapters/database/connectionManager.js

@@ -43,157 +43,157 @@ 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;
-      -- Written when a project is made (routes/project) and by its connection routes.
-      ALTER TABLE streamby.projects ADD COLUMN IF NOT EXISTS public              BOOLEAN DEFAULT TRUE;
-      ALTER TABLE streamby.projects ADD COLUMN IF NOT EXISTS category            TEXT;
-      ALTER TABLE streamby.projects ADD COLUMN IF NOT EXISTS "integrationConnections"  JSONB DEFAULT '[]';
-      ALTER TABLE streamby.projects ADD COLUMN IF NOT EXISTS "distributionConnections" JSONB DEFAULT '[]';
-      ALTER TABLE streamby.projects ADD COLUMN IF NOT EXISTS "renderFarmConnections"   JSONB DEFAULT '[]';
+        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;
+      -- Written when a project is made (routes/project) and by its connection routes.
+      ALTER TABLE streamby.projects ADD COLUMN IF NOT EXISTS public              BOOLEAN DEFAULT TRUE;
+      ALTER TABLE streamby.projects ADD COLUMN IF NOT EXISTS category            TEXT;
+      ALTER TABLE streamby.projects ADD COLUMN IF NOT EXISTS "integrationConnections"  JSONB DEFAULT '[]';
+      ALTER TABLE streamby.projects ADD COLUMN IF NOT EXISTS "distributionConnections" JSONB DEFAULT '[]';
+      ALTER TABLE streamby.projects ADD COLUMN IF NOT EXISTS "renderFarmConnections"   JSONB DEFAULT '[]';
     `);
         // 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.');
         // API tokens: only their hash is kept (see services/apiTokens). Main db only, like
         // user_integrations above. A table from before tokens had a kind and permissions gets the
         // new columns; its old tokens no longer work (they have no kind) and aren't listed.
-        await pool.query(`
-      CREATE TABLE IF NOT EXISTS streamby.api_tokens (
-        id                TEXT PRIMARY KEY DEFAULT uuid_generate_v4()::text,
-        kind              VARCHAR(10),
-        "userId"          VARCHAR(255) NOT NULL,
-        "createdByName"   VARCHAR(255),
-        name              VARCHAR(255) NOT NULL,
-        prefix            VARCHAR(32) NOT NULL,
-        hash              CHAR(64) NOT NULL UNIQUE,
-        permissions       JSONB NOT NULL DEFAULT '[]',
-        "projectIds"      JSONB NOT NULL,
-        "createdAt"       TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
-        "expiresAt"       TIMESTAMP WITH TIME ZONE,
-        "lastUsedAt"      TIMESTAMP WITH TIME ZONE
-      );
-      ALTER TABLE streamby.api_tokens ADD COLUMN IF NOT EXISTS kind VARCHAR(10);
-      ALTER TABLE streamby.api_tokens ADD COLUMN IF NOT EXISTS "createdByName" VARCHAR(255);
-      ALTER TABLE streamby.api_tokens ADD COLUMN IF NOT EXISTS permissions JSONB NOT NULL DEFAULT '[]';
-      DO $$ BEGIN
-        IF EXISTS (SELECT 1 FROM information_schema.columns
-                   WHERE table_schema = 'streamby' AND table_name = 'api_tokens' AND column_name = 'access') THEN
-          ALTER TABLE streamby.api_tokens ALTER COLUMN access DROP NOT NULL;
-        END IF;
-      END $$;
-      CREATE INDEX IF NOT EXISTS api_tokens_userid_idx ON streamby.api_tokens ("userId");
-      CREATE INDEX IF NOT EXISTS api_tokens_kind_idx ON streamby.api_tokens (kind);
+        await pool.query(`
+      CREATE TABLE IF NOT EXISTS streamby.api_tokens (
+        id                TEXT PRIMARY KEY DEFAULT uuid_generate_v4()::text,
+        kind              VARCHAR(10),
+        "userId"          VARCHAR(255) NOT NULL,
+        "createdByName"   VARCHAR(255),
+        name              VARCHAR(255) NOT NULL,
+        prefix            VARCHAR(32) NOT NULL,
+        hash              CHAR(64) NOT NULL UNIQUE,
+        permissions       JSONB NOT NULL DEFAULT '[]',
+        "projectIds"      JSONB NOT NULL,
+        "createdAt"       TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
+        "expiresAt"       TIMESTAMP WITH TIME ZONE,
+        "lastUsedAt"      TIMESTAMP WITH TIME ZONE
+      );
+      ALTER TABLE streamby.api_tokens ADD COLUMN IF NOT EXISTS kind VARCHAR(10);
+      ALTER TABLE streamby.api_tokens ADD COLUMN IF NOT EXISTS "createdByName" VARCHAR(255);
+      ALTER TABLE streamby.api_tokens ADD COLUMN IF NOT EXISTS permissions JSONB NOT NULL DEFAULT '[]';
+      DO $$ BEGIN
+        IF EXISTS (SELECT 1 FROM information_schema.columns
+                   WHERE table_schema = 'streamby' AND table_name = 'api_tokens' AND column_name = 'access') THEN
+          ALTER TABLE streamby.api_tokens ALTER COLUMN access DROP NOT NULL;
+        END IF;
+      END $$;
+      CREATE INDEX IF NOT EXISTS api_tokens_userid_idx ON streamby.api_tokens ("userId");
+      CREATE INDEX IF NOT EXISTS api_tokens_kind_idx ON streamby.api_tokens (kind);
     `);
         console.log('✅ "api_tokens" table ensured to exist.');
         // The MCP server's audit log: every tool call (see mcp/audit). Main db only.
-        await pool.query(`
-      CREATE TABLE IF NOT EXISTS streamby.mcp_audit (
-        id            TEXT PRIMARY KEY DEFAULT uuid_generate_v4()::text,
-        "userId"      VARCHAR(255) NOT NULL,
-        "tokenId"     VARCHAR(255) NOT NULL,
-        "projectId"   VARCHAR(255),
-        tool          VARCHAR(100) NOT NULL,
-        ok            BOOLEAN NOT NULL,
-        status        INTEGER,
-        error         TEXT,
-        "durationMs"  INTEGER NOT NULL,
-        "createdAt"   TIMESTAMP WITH TIME ZONE DEFAULT NOW()
-      );
-      CREATE INDEX IF NOT EXISTS mcp_audit_token_idx ON streamby.mcp_audit ("tokenId", "createdAt");
+        await pool.query(`
+      CREATE TABLE IF NOT EXISTS streamby.mcp_audit (
+        id            TEXT PRIMARY KEY DEFAULT uuid_generate_v4()::text,
+        "userId"      VARCHAR(255) NOT NULL,
+        "tokenId"     VARCHAR(255) NOT NULL,
+        "projectId"   VARCHAR(255),
+        tool          VARCHAR(100) NOT NULL,
+        ok            BOOLEAN NOT NULL,
+        status        INTEGER,
+        error         TEXT,
+        "durationMs"  INTEGER NOT NULL,
+        "createdAt"   TIMESTAMP WITH TIME ZONE DEFAULT NOW()
+      );
+      CREATE INDEX IF NOT EXISTS mcp_audit_token_idx ON streamby.mcp_audit ("tokenId", "createdAt");
     `);
         console.log('✅ "mcp_audit" 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/apiConnection.d.ts

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

package/dist/middleware/routes/apiConnection.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.apiConnectionRouter = apiConnectionRouter;
+const express_1 = require("express");
+const manager_1 = require("../../models/manager");
+const auth_1 = require("../../utils/auth");
+const apiConnection_1 = require("../../services/apiConnection");
+const VALID_METHODS = ['GET', 'POST', 'PATCH', 'PUT', 'DELETE'];
+function apiConnectionRouter(config) {
+    const router = (0, express_1.Router)();
+    const Project = (0, manager_1.getModel)('projects');
+    // List API connections for a project
+    router.get('/projects/:id/api/connections', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const projectId = req.params.id;
+            const project = await Project.findOne({ _id: projectId });
+            if (!project) {
+                return res.status(404).json({ message: 'Project not found' });
+            }
+            if (!(0, auth_1.isProjectMember)(project, auth.userId)) {
+                return res.status(403).json({ message: 'Unauthorized project access' });
+            }
+            return res.status(200).json({ data: project.apiConnections || [] });
+        }
+        catch (err) {
+            res.status(500).json({ message: 'Failed to fetch API connections', details: err.message });
+        }
+    });
+    // Add a new API connection to a project
+    router.post('/projects/:id/api/connections', async (req, res) => {
+        try {
+            const auth = req.auth;
+            if (auth.role !== 'admin' && auth.role !== 'editor') {
+                return res.status(403).json({ message: 'Permission denied' });
+            }
+            const projectId = req.params.id;
+            const { name, baseUrl, method, description, credentialId, prefix } = req.body;
+            if (!name || !baseUrl) {
+                return res.status(400).json({ message: 'name and baseUrl are required' });
+            }
+            if (!VALID_METHODS.includes(method)) {
+                return res.status(400).json({ message: `method must be one of: ${VALID_METHODS.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 project access' });
+            }
+            if (credentialId) {
+                const credExists = project.credentials?.some((c) => c.id === credentialId);
+                if (!credExists) {
+                    return res.status(400).json({ message: 'Credential not found in project' });
+                }
+            }
+            const connection = await (0, apiConnection_1.addApiConnection)(config, projectId, {
+                name,
+                baseUrl,
+                method,
+                prefix,
+                ...(description !== undefined && { description }),
+                ...(credentialId !== undefined && { credentialId }),
+            });
+            return res.status(201).json({ data: connection });
+        }
+        catch (err) {
+            res.status(500).json({ message: 'Failed to add API connection', details: err.message });
+        }
+    });
+    // Delete an API connection from a project
+    router.delete('/projects/:id/api/connections/:connectionId', async (req, res) => {
+        try {
+            const auth = req.auth;
+            if (auth.role !== 'admin' && auth.role !== 'editor') {
+                return res.status(403).json({ message: 'Permission denied' });
+            }
+            const projectId = req.params.id;
+            const { connectionId } = 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 project access' });
+            }
+            const exists = project.apiConnections?.some((c) => c.id === connectionId);
+            if (!exists) {
+                return res.status(404).json({ message: 'API connection not found' });
+            }
+            await (0, apiConnection_1.deleteApiConnection)(config, projectId, connectionId);
+            return res.status(200).json({ message: 'API connection deleted successfully.' });
+        }
+        catch (err) {
+            res.status(500).json({ message: 'Failed to delete API connection', details: err.message });
+        }
+    });
+    return router;
+}

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

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

package/dist/middleware/routes/credential.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.credentialRouter = credentialRouter;
+const express_1 = require("express");
+const manager_1 = require("../../models/manager");
+const auth_1 = require("../../utils/auth");
+const sanitize_1 = require("../../utils/sanitize");
+const credential_1 = require("../../services/credential");
+function credentialRouter(config) {
+    const router = (0, express_1.Router)();
+    const Project = (0, manager_1.getModel)('projects');
+    // Add a new credential to a project
+    router.post('/projects/:id/credentials', async (req, res) => {
+        try {
+            const auth = req.auth;
+            if (auth.role !== 'admin' && auth.role !== 'editor') {
+                return res.status(403).json({ message: 'Permission denied' });
+            }
+            const projectId = req.params.id;
+            const { id, key, value } = req.body;
+            if (!key || !value) {
+                return res.status(400).json({ message: 'Missing credential key or value' });
+            }
+            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' });
+            }
+            const updatedProject = await (0, credential_1.addCredential)(config, projectId, { id, key, value });
+            res.status(201).json({ message: 'Credential added successfully', project: (0, sanitize_1.sanitizeProject)(updatedProject) });
+        }
+        catch (err) {
+            res.status(500).json({ message: 'Failed to add credential', details: err.message });
+        }
+    });
+    // Update an existing credential in a project
+    router.patch('/projects/:id/credentials/:credentialId', async (req, res) => {
+        try {
+            const auth = req.auth;
+            if (auth.role !== 'admin' && auth.role !== 'editor') {
+                return res.status(403).json({ message: 'Permission denied' });
+            }
+            const projectId = req.params.id;
+            const credentialId = req.params.credentialId;
+            const { key, value } = req.body;
+            if (!key && !value) {
+                return res.status(400).json({ message: 'No update fields provided' });
+            }
+            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' });
+            }
+            const updatedProject = await (0, credential_1.updateCredential)(config, projectId, credentialId, { key, value });
+            res.status(200).json({ message: 'Credential updated successfully', project: (0, sanitize_1.sanitizeProject)(updatedProject) });
+        }
+        catch (err) {
+            res.status(500).json({ message: 'Failed to update credential', details: err.message });
+        }
+    });
+    // Delete a credential from a project
+    router.delete('/projects/:id/credentials/:credentialId', async (req, res) => {
+        try {
+            const auth = req.auth;
+            if (auth.role !== 'admin' && auth.role !== 'editor') {
+                return res.status(403).json({ message: 'Permission denied' });
+            }
+            const projectId = req.params.id;
+            const credentialId = req.params.credentialId;
+            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' });
+            }
+            const updatedProject = await (0, credential_1.deleteCredential)(config, projectId, credentialId);
+            res.status(200).json({ message: 'Credential deleted successfully', project: (0, sanitize_1.sanitizeProject)(updatedProject) });
+        }
+        catch (err) {
+            res.status(500).json({ message: 'Failed to delete credential', details: err.message });
+        }
+    });
+    return router;
+}

package/dist/middleware/routes/export.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.exportRouter = exportRouter;
 const express_1 = require("express");
 const deliverables_1 = require("../../services/deliverables");
+const sanitize_1 = require("../../utils/sanitize");
 const manager_1 = require("../../models/manager");
 const auth_1 = require("../../utils/auth");
 const export_1 = require("../../services/export");
@@ -61,6 +62,21 @@ const DEFAULT_NODE_SCHEMA = {
 function exportRouter(config) {
     const router = (0, express_1.Router)();
     const Project = (0, manager_1.getModel)('projects');
+    // ─── A project's exports, on their own ────────────────────────────────────
+    router.get('/projects/:id/exports', 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 access' });
+            return res.status(200).json({ data: (0, sanitize_1.exportSummaries)(project.exports) });
+        }
+        catch (err) {
+            res.status(500).json({ message: 'Failed to fetch exports', details: err.message });
+        }
+    });
     router.get('/projects/:id/exports/:export_id', async (req, res) => {
         try {
             const auth = await config.authProvider(req);

package/dist/middleware/routes/project.js

@@ -196,15 +196,7 @@ function projectRouter(config) {
             if (!(0, auth_1.isProjectMember)(project, auth.userId)) {
                 return res.status(403).json({ message: 'Unauthorized project access' });
             }
-            const exports = (project.exports || []).map((e) => ({
-                id: e.id,
-                name: e.name,
-                description: e.description,
-                method: e.method,
-                private: e.private,
-                useConnections: e.useConnections,
-                useCredentials: e.useCredentials,
-            }));
+            const exports = (0, sanitize_1.exportSummaries)(project.exports);
             const sanitized = (0, sanitize_1.sanitizeProject)({ ...project, id: project._id || project.id, _id: undefined, connections: project.connections || [], exports });
             // Whether it has production data, for its Production section to show even without a
             // production node in its workflow.
@@ -381,6 +373,21 @@ function projectRouter(config) {
             res.status(500).json({ message: 'Failed to update project image', details: err.message });
         }
     });
+    // ─── A project's allowed origins, on their own ────────────────────────────
+    router.get('/projects/:id/origins', 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' });
+            return res.status(200).json({ data: project.allowedOrigin || [] });
+        }
+        catch (err) {
+            res.status(500).json({ message: 'Failed to fetch project origins', details: err.message });
+        }
+    });
     router.patch('/projects/:id/origins', async (req, res) => {
         try {
             const auth = req.auth;
@@ -403,6 +410,21 @@ function projectRouter(config) {
             res.status(500).json({ message: 'Failed to update project origins', details: err.message });
         }
     });
+    // ─── A project's integrations, on their own ───────────────────────────────
+    router.get('/projects/:id/integrations', 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' });
+            return res.status(200).json({ data: (0, sanitize_1.sanitizeIntegrationConnections)(project.integrationConnections) });
+        }
+        catch (err) {
+            res.status(500).json({ message: 'Failed to fetch project integrations', details: err.message });
+        }
+    });
     // ─── Add an integration to an existing project ───────────────────────────
     router.post('/projects/:id/integrations', async (req, res) => {
         try {

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]);
         }
     }

package/dist/services/apiConnection.d.ts

@@ -0,0 +1,18 @@
+import { StreamByConfig, ApiConnection, ApiConnectionMethod } from '../types';
+export declare function addApiConnection(config: StreamByConfig, projectId: string, data: {
+    name: string;
+    apiUrl: string;
+    method: ApiConnectionMethod;
+    prefix?: string;
+    description?: string;
+    credentialId?: string;
+}): Promise<ApiConnection>;
+export declare function updateApiConnection(config: StreamByConfig, projectId: string, connectionId: string, data: {
+    name?: string;
+    apiUrl?: string;
+    method?: ApiConnectionMethod;
+    prefix?: string;
+    description?: string;
+    credentialId?: string;
+}): Promise<ApiConnection>;
+export declare function deleteApiConnection(config: StreamByConfig, projectId: string, connectionId: string): Promise<void>;