streamby-core 0.41.0 → 0.43.0

package/dist/middleware/routes/dbConnection.js

@@ -2,6 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.dbConnectionRouter = dbConnectionRouter;
 const express_1 = require("express");
+const workflowResources_1 = require("../../services/workflowResources");
+const projectResources_1 = require("./projectResources");
+const projectIntegration_1 = require("../../services/projectIntegration");
 const mongodb_1 = require("mongodb");
 const manager_1 = require("../../models/manager");
 const auth_1 = require("../../utils/auth");
@@ -45,11 +48,29 @@ function dbConnectionRouter(config) {
             res.status(500).json({ message: 'Failed to fetch DB connections', details: err.message });
         }
     });
+    // The project's database connections as they're answered, after each change too.
+    const listNow = async (projectId) => (0, sanitize_1.sanitizeConnections)((await Project.findOne({ _id: projectId }))?.dbConnections);
     // ─── Add DB connection ────────────────────────────────────────────────────
     router.post('/projects/:id/connections/db', async (req, res) => {
         try {
             const auth = req.auth;
             const { name, dbType, credential, integrationId, description } = req.body;
+            if (credential && integrationId) {
+                return res.status(400).json({ message: 'Provide only one of credential or integrationId' });
+            }
+            // An integration (the user's, or a built-in) is a named, typed database already.
+            if (integrationId) {
+                const project = await Project.findOne({ _id: req.params.id });
+                if (!project)
+                    return res.status(404).json({ message: 'Project not found' });
+                if (!(0, auth_1.canEditProject)(project, auth.userId))
+                    return res.status(403).json({ message: 'Unauthorized project access' });
+                const result = await (0, projectIntegration_1.connectIntegration)(project, integrationId, auth, config, { kind: 'database', description });
+                if ('error' in result)
+                    return res.status(result.status).json({ message: result.error });
+                await (0, workflowResources_1.addToWorkflow)(req.params.id, 'db', result.connection);
+                return res.status(201).json({ data: (0, sanitize_1.sanitizeConnection)(result.connection), dbConnections: await listNow(req.params.id) });
+            }
             if (!name || !dbType) {
                 return res.status(400).json({ message: 'name and dbType are required' });
             }
@@ -93,7 +114,8 @@ function dbConnectionRouter(config) {
                 ...(description !== undefined && { description }),
             };
             await Project.update({ _id: req.params.id }, { $push: { dbConnections: connection } });
-            return res.status(201).json({ data: (0, sanitize_1.sanitizeConnection)(connection) });
+            await (0, workflowResources_1.addToWorkflow)(req.params.id, 'db', connection);
+            return res.status(201).json({ data: (0, sanitize_1.sanitizeConnection)(connection), dbConnections: await listNow(req.params.id) });
         }
         catch (err) {
             res.status(500).json({ message: 'Failed to add DB connection', details: err.message });
@@ -111,11 +133,13 @@ function dbConnectionRouter(config) {
             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') {
-                return res.status(403).json({ message: 'Cannot delete a built-in database connection' });
-            }
+            // A built-in is disconnected, not deleted: what the project keeps in it stays, and it can
+            // be connected again (routes/projectResources).
             await Project.update({ _id: req.params.id }, { $pull: { dbConnections: { id: req.params.connId } } });
-            return res.status(200).json({ message: 'DB connection deleted successfully' });
+            if (conn.source === 'builtin')
+                await (0, projectResources_1.rememberDisconnectedBuiltin)(req.params.id, 'db', conn);
+            await (0, workflowResources_1.removeFromWorkflow)(req.params.id, 'db', req.params.connId);
+            return res.status(200).json({ message: 'DB connection deleted successfully', dbConnections: await listNow(req.params.id) });
         }
         catch (err) {
             res.status(500).json({ message: 'Failed to delete DB connection', details: err.message });

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

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

package/dist/middleware/routes/document.js

@@ -0,0 +1,348 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.documentRouter = documentRouter;
+const express_1 = require("express");
+const crypto_1 = __importDefault(require("crypto"));
+const manager_1 = require("../../models/manager");
+const auth_1 = require("../../utils/auth");
+const wsHub_1 = require("../../services/wsHub");
+const documents_1 = require("../../services/documents");
+const auth_2 = require("../../services/auth");
+const creditsSheets_1 = require("../../services/creditsSheets");
+const MAX_TITLE = 200;
+const MAX_CONTENT = 1000000;
+// What happened to a project's documents, to whoever is in it now: a view of a document
+// refreshes itself, an editor warns of a newer version. `version` and `author` come with a save.
+function broadcast(project, data) {
+    const projectId = String(project._id ?? project.id);
+    for (const member of project.members ?? []) {
+        if ((0, auth_1.activeMemberOf)(project, member.userId))
+            (0, wsHub_1.emitToUser)(member.userId, { type: 'documentEvent', data: { projectId, ...data } });
+    }
+}
+const isVersion = (value) => Number.isInteger(value) && value >= 1;
+function checkTitle(value) {
+    if (typeof value !== 'string' || !value.trim())
+        return { error: 'A title is required' };
+    if (value.trim().length > MAX_TITLE)
+        return { error: `A title has at most ${MAX_TITLE} characters` };
+    return value.trim();
+}
+function checkContent(value, kind = 'document') {
+    if (kind === 'credits')
+        return (0, creditsSheets_1.checkSheetContent)(value);
+    if (typeof value !== 'string')
+        return { error: 'content must be text (markdown)' };
+    if (value.length > MAX_CONTENT)
+        return { error: `A document has at most ${MAX_CONTENT} characters` };
+    return value;
+}
+// Where a document may go: the top (null), or a folder of the same project that isn't the
+// document itself nor inside it.
+function checkParent(value, documents, movingId) {
+    if (value === null)
+        return null;
+    if (typeof value !== 'string')
+        return { error: 'parentId must be a folder\'s id, or null' };
+    const parent = documents.find(d => d.id === value);
+    if (!parent)
+        return { error: 'No such folder in this project' };
+    if (parent.kind !== 'folder')
+        return { error: 'A document goes in a folder, not in another document' };
+    if (movingId && (0, documents_1.withDescendants)(documents, movingId).includes(value))
+        return { error: 'A folder can\'t go inside itself' };
+    return value;
+}
+const failed = (value) => typeof value === 'object' && value !== null && 'error' in value;
+function documentRouter(_config) {
+    const router = (0, express_1.Router)();
+    const Project = (0, manager_1.getModel)('projects');
+    // The project, if the caller may see it (or, with `edit`, change it); otherwise the answer.
+    async function projectFor(req, res, edit = false) {
+        const auth = req.auth;
+        const project = await Project.findOne({ _id: req.params.projectId });
+        if (!project) {
+            res.status(404).json({ message: 'Project not found' });
+            return null;
+        }
+        if (!(edit ? auth_1.canEditProject : auth_1.isProjectMember)(project, auth.userId)) {
+            res.status(403).json({ message: 'Unauthorized' });
+            return null;
+        }
+        return { project, auth, projectId: String(req.params.projectId) };
+    }
+    const conflict = (res, current) => res.status(409).json({
+        message: `The document changed: it's at version ${current.version} now. Read it again, and make the change on that version.`,
+        document: current,
+    });
+    router.get('/projects/:projectId/documents', async (req, res) => {
+        try {
+            const found = await projectFor(req, res);
+            if (!found)
+                return;
+            res.json({ documents: await (0, documents_1.documentStore)().list(found.projectId) });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    router.post('/projects/:projectId/documents', async (req, res) => {
+        try {
+            const found = await projectFor(req, res, true);
+            if (!found)
+                return;
+            const { project, auth, projectId } = found;
+            if (req.body?.kind !== undefined && !['document', 'folder', 'credits'].includes(req.body.kind))
+                return res.status(400).json({ message: "kind is 'document', 'folder' or 'credits'" });
+            const kind = req.body?.kind ?? 'document';
+            const title = checkTitle(req.body?.title);
+            if (failed(title))
+                return res.status(400).json({ message: title.error });
+            if (kind === 'folder' && req.body?.content)
+                return res.status(400).json({ message: 'A folder has no content' });
+            const content = kind === 'folder' ? '' : checkContent(req.body?.content ?? '', kind);
+            if (failed(content))
+                return res.status(400).json({ message: content.error });
+            const store = (0, documents_1.documentStore)();
+            const documents = await store.list(projectId);
+            const parentId = checkParent(req.body?.parentId ?? null, documents);
+            if (failed(parentId))
+                return res.status(400).json({ message: parentId.error });
+            if (req.body?.position !== undefined && !Number.isInteger(req.body.position))
+                return res.status(400).json({ message: 'position must be a whole number' });
+            // At the end of its folder, unless placed.
+            const siblings = documents.filter(d => d.parentId === parentId);
+            const position = req.body?.position ?? (siblings.length ? Math.max(...siblings.map(d => d.position)) + 1 : 0);
+            const now = new Date();
+            const author = (0, documents_1.authorOf)(auth);
+            const document = await store.create({
+                id: crypto_1.default.randomUUID(), projectId, kind, title, parentId, position, content, version: 1,
+                exportable: false, publishedVersion: null, createdAt: now, createdBy: author, updatedAt: now, updatedBy: author,
+            });
+            broadcast(project, { action: 'created', documentIds: [document.id], version: 1, title, author });
+            res.status(201).json({ document });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    router.get('/projects/:projectId/documents/:docId', async (req, res) => {
+        try {
+            const found = await projectFor(req, res);
+            if (!found)
+                return;
+            const document = await (0, documents_1.documentStore)().get(found.projectId, req.params.docId);
+            if (!document)
+                return res.status(404).json({ message: 'Document not found' });
+            res.json({ document });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    // Its title or content (a new version, made on `baseVersion`), and where it is in the tree
+    // or whether it's exportable (not a version).
+    router.patch('/projects/:projectId/documents/:docId', async (req, res) => {
+        try {
+            const found = await projectFor(req, res, true);
+            if (!found)
+                return;
+            const { project, auth, projectId } = found;
+            const { docId } = req.params;
+            const body = req.body ?? {};
+            const store = (0, documents_1.documentStore)();
+            const current = await store.get(projectId, docId);
+            if (!current)
+                return res.status(404).json({ message: 'Document not found' });
+            const changesText = body.title !== undefined || body.content !== undefined;
+            const changesPlace = body.parentId !== undefined || body.position !== undefined || body.exportable !== undefined;
+            if (!changesText && !changesPlace)
+                return res.status(400).json({ message: 'Nothing to change: title, content, parentId, position or exportable' });
+            // Everything is checked before anything changes.
+            let text;
+            if (changesText) {
+                if (!isVersion(body.baseVersion))
+                    return res.status(400).json({ message: 'baseVersion is required: the version the change was made on' });
+                const title = body.title === undefined ? current.title : checkTitle(body.title);
+                if (failed(title))
+                    return res.status(400).json({ message: title.error });
+                if (current.kind === 'folder' && body.content)
+                    return res.status(400).json({ message: 'A folder has no content' });
+                const content = body.content === undefined ? current.content : checkContent(body.content, current.kind);
+                if (failed(content))
+                    return res.status(400).json({ message: content.error });
+                text = { title, content };
+            }
+            const place = {};
+            if (body.parentId !== undefined) {
+                const parentId = checkParent(body.parentId, await store.list(projectId), docId);
+                if (failed(parentId))
+                    return res.status(400).json({ message: parentId.error });
+                place.parentId = parentId;
+            }
+            if (body.position !== undefined) {
+                if (!Number.isInteger(body.position))
+                    return res.status(400).json({ message: 'position must be a whole number' });
+                place.position = body.position;
+            }
+            if (body.exportable !== undefined) {
+                // Whether its exports deliver it is publishing it: a token needs docs:publish.
+                if (auth.apiToken && !(0, auth_2.tokenAllows)(auth.apiToken, 'docs:publish')) {
+                    return res.status(403).json({ error: "This API token doesn't have the 'docs:publish' permission" });
+                }
+                if (typeof body.exportable !== 'boolean')
+                    return res.status(400).json({ message: 'exportable is true or false' });
+                if (current.kind === 'folder')
+                    return res.status(400).json({ message: 'A folder isn\'t exported: its documents are' });
+                place.exportable = body.exportable;
+            }
+            const author = (0, documents_1.authorOf)(auth);
+            let document = current;
+            if (text) {
+                document = await store.save(projectId, docId, body.baseVersion, text, author, new Date());
+                if (!document) {
+                    const now = await store.get(projectId, docId);
+                    return now ? conflict(res, now) : res.status(404).json({ message: 'Document not found' });
+                }
+            }
+            if (changesPlace)
+                document = await store.update(projectId, docId, place);
+            if (!document)
+                return res.status(404).json({ message: 'Document not found' });
+            broadcast(project, text
+                ? { action: 'saved', documentIds: [docId], version: document.version, title: document.title, author }
+                : { action: 'changed', documentIds: [docId], author });
+            res.json({ document });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    // What's under one of its headings, the rest untouched: a new version, made on `baseVersion`.
+    router.patch('/projects/:projectId/documents/:docId/sections', async (req, res) => {
+        try {
+            const found = await projectFor(req, res, true);
+            if (!found)
+                return;
+            const { project, auth, projectId } = found;
+            const { docId } = req.params;
+            const { baseVersion, heading, content } = req.body ?? {};
+            if (!isVersion(baseVersion))
+                return res.status(400).json({ message: 'baseVersion is required: the version the change was made on' });
+            if (typeof heading !== 'string' || !heading.trim())
+                return res.status(400).json({ message: 'heading is required: the section\'s heading, e.g. "## Architecture"' });
+            const body = checkContent(content);
+            if (failed(body))
+                return res.status(400).json({ message: body.error });
+            const store = (0, documents_1.documentStore)();
+            const current = await store.get(projectId, docId);
+            if (!current)
+                return res.status(404).json({ message: 'Document not found' });
+            if (current.kind === 'folder')
+                return res.status(400).json({ message: 'A folder has no content' });
+            if (current.kind === 'credits')
+                return res.status(400).json({ message: 'A credits sheet has no sections: its content is its sources' });
+            // A section of another version than the one it was read on could be another text.
+            if (current.version !== baseVersion)
+                return conflict(res, current);
+            const replaced = (0, documents_1.replaceSection)(current.content, heading, body);
+            if ('error' in replaced) {
+                return replaced.error === 'not-found'
+                    ? res.status(404).json({ message: `No section "${heading.trim()}" in the document` })
+                    : res.status(400).json({ message: `More than one section is "${heading.trim()}": give the heading with its #s, or update the whole document` });
+            }
+            const author = (0, documents_1.authorOf)(auth);
+            const document = await store.save(projectId, docId, baseVersion, { title: current.title, content: replaced.content }, author, new Date());
+            if (!document) {
+                const now = await store.get(projectId, docId);
+                return now ? conflict(res, now) : res.status(404).json({ message: 'Document not found' });
+            }
+            broadcast(project, { action: 'saved', documentIds: [docId], version: document.version, title: document.title, author });
+            res.json({ document });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    router.get('/projects/:projectId/documents/:docId/versions', async (req, res) => {
+        try {
+            const found = await projectFor(req, res);
+            if (!found)
+                return;
+            const store = (0, documents_1.documentStore)();
+            if (!(await store.get(found.projectId, req.params.docId)))
+                return res.status(404).json({ message: 'Document not found' });
+            res.json({ versions: await store.versions(found.projectId, req.params.docId) });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    router.get('/projects/:projectId/documents/:docId/versions/:version', async (req, res) => {
+        try {
+            const found = await projectFor(req, res);
+            if (!found)
+                return;
+            const number = Number(req.params.version);
+            const version = isVersion(number) ? await (0, documents_1.documentStore)().version(found.projectId, req.params.docId, number) : null;
+            if (!version)
+                return res.status(404).json({ message: 'Version not found' });
+            res.json({ version });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    // The version its exports deliver (null: none, it's no longer published). Editing it later
+    // changes nothing exported until another version is published.
+    router.post('/projects/:projectId/documents/:docId/publish', async (req, res) => {
+        try {
+            const found = await projectFor(req, res, true);
+            if (!found)
+                return;
+            const { project, auth, projectId } = found;
+            const { docId } = req.params;
+            const version = req.body?.version;
+            if (version !== null && !isVersion(version))
+                return res.status(400).json({ message: 'version is the version to publish, or null to publish none' });
+            const store = (0, documents_1.documentStore)();
+            const current = await store.get(projectId, docId);
+            if (!current)
+                return res.status(404).json({ message: 'Document not found' });
+            if (current.kind === 'folder')
+                return res.status(400).json({ message: 'A folder isn\'t published: its documents are' });
+            if (version !== null && version > current.version)
+                return res.status(404).json({ message: 'Version not found' });
+            const document = await store.update(projectId, docId, { publishedVersion: version });
+            broadcast(project, { action: 'changed', documentIds: [docId], author: (0, documents_1.authorOf)(auth) });
+            res.json({ document });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    // A document, or a folder with everything in it.
+    router.delete('/projects/:projectId/documents/:docId', async (req, res) => {
+        try {
+            const found = await projectFor(req, res, true);
+            if (!found)
+                return;
+            const { project, auth, projectId } = found;
+            const store = (0, documents_1.documentStore)();
+            const documents = await store.list(projectId);
+            if (!documents.some(d => d.id === req.params.docId))
+                return res.status(404).json({ message: 'Document not found' });
+            const ids = (0, documents_1.withDescendants)(documents, req.params.docId);
+            await store.remove(projectId, ids);
+            broadcast(project, { action: 'deleted', documentIds: ids, author: (0, documents_1.authorOf)(auth) });
+            res.json({ deleted: ids });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    return router;
+}

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

@@ -1,3 +1,31 @@
 import { Router } from 'express';
 import { StreamByConfig } from '../../types';
+export declare const DEFAULT_NODE_SCHEMA: {
+    nodes: {
+        id: string;
+        type: string;
+        position: {
+            x: number;
+            y: number;
+        };
+        data: {
+            label: string;
+            subtitle: string;
+        };
+        width: number;
+        height: number;
+    }[];
+    edges: {
+        id: string;
+        source: string;
+        sourceHandle: string;
+        target: string;
+        targetHandle: string;
+        animated: boolean;
+        style: {
+            stroke: string;
+            strokeWidth: number;
+        };
+    }[];
+};
 export declare function exportRouter(config: StreamByConfig): Router;

package/dist/middleware/routes/export.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_NODE_SCHEMA = void 0;
 exports.exportRouter = exportRouter;
 const express_1 = require("express");
+const workflowResources_1 = require("../../services/workflowResources");
 const deliverables_1 = require("../../services/deliverables");
 const sanitize_1 = require("../../utils/sanitize");
 const manager_1 = require("../../models/manager");
@@ -11,7 +13,7 @@ const executor_1 = require("../../services/executor");
 const connectionManager_1 = require("../../adapters/database/connectionManager");
 const mongodb_1 = require("mongodb");
 const encryption_1 = require("../../utils/encryption");
-const DEFAULT_NODE_SCHEMA = {
+exports.DEFAULT_NODE_SCHEMA = {
     nodes: [
         {
             id: 'request',
@@ -251,7 +253,7 @@ function exportRouter(config) {
             if (!name) {
                 return res.status(400).json({ message: 'Missing export name' });
             }
-            const resolvedNodeSchema = nodeSchema ?? DEFAULT_NODE_SCHEMA;
+            const resolvedNodeSchema = nodeSchema ?? exports.DEFAULT_NODE_SCHEMA;
             const exportType = useConnections ? 'externalApi' : 'json';
             const project = await Project.findOne({ _id: projectId });
             if (!project || !(0, auth_1.canEditProject)(project, auth.userId)) {
@@ -260,7 +262,8 @@ function exportRouter(config) {
             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 });
+            await (0, workflowResources_1.addToWorkflow)(projectId, 'export', { id: result.exportId, name, method: 'GET' });
+            res.status(201).json({ data: result, exports: (0, sanitize_1.exportSummaries)((await Project.findOne({ _id: projectId }))?.exports), message: result.message });
         }
         catch (err) {
             res.status(500).json({ message: 'Failed to create raw export', details: err.message });
@@ -310,7 +313,8 @@ function exportRouter(config) {
             }
             await (0, export_1.deleteExport)(config, projectId, exportId, project.dbType);
             await (0, deliverables_1.deleteDeliverablesOf)(projectId, { exportId });
-            res.status(200).json({ message: 'Export deleted successfully' });
+            await (0, workflowResources_1.removeFromWorkflow)(projectId, 'export', exportId);
+            res.status(200).json({ message: 'Export deleted successfully', exports: (0, sanitize_1.exportSummaries)((await Project.findOne({ _id: projectId }))?.exports) });
         }
         catch (err) {
             res.status(500).json({ message: 'Failed to delete export', details: err.message });

package/dist/middleware/routes/pipeline.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.pipelineRouter = pipelineRouter;
 const express_1 = require("express");
+const workflowResources_1 = require("../../services/workflowResources");
 const auth_1 = require("../../utils/auth");
 const connectionManager_1 = require("../../adapters/database/connectionManager");
 const manager_1 = require("../../models/manager");
@@ -86,7 +87,8 @@ function pipelineRouter(_config) {
             };
             await db.collection('pipelines').insertOne({ ...pipeline });
             await syncProjectRefs(projectId);
-            res.status(201).json({ pipeline });
+            await (0, workflowResources_1.addToWorkflow)(projectId, 'pipeline', pipeline);
+            res.status(201).json({ pipeline, pipelines: (await Project.findOne({ _id: projectId }))?.pipelines ?? [] });
         }
         catch (err) {
             res.status(500).json({ message: err.message });
@@ -161,7 +163,8 @@ function pipelineRouter(_config) {
                 return res.status(500).json({ message: 'Database not available' });
             await db.collection('pipelines').deleteOne({ id: pipelineId, projectId });
             await syncProjectRefs(projectId);
-            res.json({ message: 'Pipeline deleted' });
+            await (0, workflowResources_1.removeFromWorkflow)(projectId, 'pipeline', pipelineId);
+            res.json({ message: 'Pipeline deleted', pipelines: (await Project.findOne({ _id: projectId }))?.pipelines ?? [] });
         }
         catch (err) {
             res.status(500).json({ message: err.message });

package/dist/middleware/routes/project.js

@@ -2,17 +2,20 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.projectRouter = projectRouter;
 const express_1 = require("express");
+const workflowResources_1 = require("../../services/workflowResources");
 const manager_1 = require("../../models/manager");
 const auth_1 = require("../../utils/auth");
 const connectionManager_1 = require("../../adapters/database/connectionManager");
 const sql_1 = require("../../adapters/database/sql");
 const sanitize_1 = require("../../utils/sanitize");
 const projectIntegration_1 = require("../../services/projectIntegration");
+const projectResources_1 = require("./projectResources");
 const auth_2 = require("../../services/auth");
 const apiTokens_1 = require("../../services/apiTokens");
 const nosqlDb_1 = require("../../utils/nosqlDb");
 const production_1 = require("../../services/production");
 const jobStore_1 = require("../../services/jobStore");
+const documents_1 = require("../../services/documents");
 function projectRouter(config) {
     const router = (0, express_1.Router)();
     const Project = (0, manager_1.getModel)('projects');
@@ -261,6 +264,8 @@ function projectRouter(config) {
             await (0, production_1.deleteProductionData)(String(projectId));
             if (projectId)
                 await (0, jobStore_1.jobStore)().deleteProject(String(projectId));
+            if (projectId)
+                await (0, documents_1.documentStore)().deleteProject(String(projectId));
             const allProjects = await Project.find({});
             const projects = allProjects
                 .filter(project => {
@@ -442,18 +447,11 @@ function projectRouter(config) {
                 return res.status(404).json({ message: 'Project not found' });
             if (!(0, auth_1.canEditProject)(project, auth.userId))
                 return res.status(403).json({ message: 'Unauthorized project access' });
-            const alreadyConnected = [...(project.dbConnections ?? []), ...(project.storageConnections ?? []), ...(project.integrationConnections ?? [])]
-                .some((c) => c.integrationId === integrationId);
-            if (alreadyConnected)
-                return res.status(400).json({ message: 'This integration is already connected to the project' });
-            const result = await (0, projectIntegration_1.classifyIntegrationId)(integrationId, auth, config, projectId);
+            const result = await (0, projectIntegration_1.connectIntegration)(project, integrationId, auth, config);
             if ('error' in result)
                 return res.status(result.status).json({ message: result.error });
-            const updated = result.kind === 'database'
-                ? await Project.update({ _id: projectId }, { $push: { dbConnections: result.connection } })
-                : result.kind === 'storage'
-                    ? await Project.update({ _id: projectId }, { $push: { storageConnections: result.connection } })
-                    : await Project.update({ _id: projectId }, { $push: { integrationConnections: result.connection } });
+            await (0, workflowResources_1.addToWorkflow)(projectId, result.kind === 'database' ? 'db' : result.kind, result.connection);
+            const updated = await Project.findOne({ _id: projectId });
             if (!updated)
                 return res.status(404).json({ message: 'Project not found or not updated' });
             res.status(201).json({ data: result.connection, project: (0, sanitize_1.sanitizeProject)(updated) });
@@ -478,13 +476,20 @@ function projectRouter(config) {
             const integrationConn = (project.integrationConnections ?? []).find((c) => c.integrationId === integrationId);
             if (!dbConn && !storageConn && !integrationConn)
                 return res.status(404).json({ message: 'Integration not connected to this project' });
-            const updated = dbConn
+            const removed = dbConn
                 ? await Project.update({ _id: projectId }, { $pull: { dbConnections: { id: dbConn.id } } })
                 : storageConn
                     ? await Project.update({ _id: projectId }, { $pull: { storageConnections: { id: storageConn.id } } })
                     : await Project.update({ _id: projectId }, { $pull: { integrationConnections: { id: integrationConn.id } } });
-            if (!updated)
+            if (!removed)
                 return res.status(404).json({ message: 'Project not found or not updated' });
+            // A built-in disconnected keeps its id, to come back as it was (services/projectIntegration).
+            const builtin = [dbConn, storageConn].find(c => c?.source === 'builtin');
+            if (builtin)
+                await (0, projectResources_1.rememberDisconnectedBuiltin)(projectId, dbConn ? 'db' : 'storage', builtin);
+            const gone = dbConn ?? storageConn ?? integrationConn;
+            await (0, workflowResources_1.removeFromWorkflow)(projectId, dbConn ? 'db' : storageConn ? 'storage' : 'service', gone.id);
+            const updated = await Project.findOne({ _id: projectId });
             res.status(200).json({ message: 'Integration removed', project: (0, sanitize_1.sanitizeProject)(updated) });
         }
         catch (err) {

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

@@ -0,0 +1,8 @@
+import { Router } from 'express';
+import { StreamByConfig } from '../../types';
+export declare function projectResourcesRouter(_config: StreamByConfig): Router;
+/** A built-in disconnected: its id kept, to connect it again as it was (services/projectIntegration). */
+export declare function rememberDisconnectedBuiltin(projectId: string, kind: 'db' | 'storage', conn: {
+    id: string;
+    integrationId?: string;
+}): Promise<void>;