streamby-core 0.41.0 → 0.43.0

package/dist/middleware/routes/workflow.js

@@ -2,16 +2,25 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.workflowRouter = workflowRouter;
 const express_1 = require("express");
-const crypto_1 = require("crypto");
 const manager_1 = require("../../models/manager");
 const auth_1 = require("../../utils/auth");
-const mongodb_1 = require("mongodb");
+const projectIntegration_1 = require("../../services/projectIntegration");
+const connection_1 = require("../../services/connection");
+const export_1 = require("../../services/export");
+const export_2 = require("./export");
+const workflowResources_1 = require("../../services/workflowResources");
+const isSchema = (value) => !!value && typeof value === 'object' && !Array.isArray(value) && Array.isArray(value.nodes) && Array.isArray(value.edges);
+// The integration kind a node's pending connection is of, by the node's type, and its field.
+const INTEGRATION_KIND = {
+    dataSourceNode: { kind: 'database', field: 'connectionId' },
+    ingestNode: { kind: 'storage', field: 'storageConnectionId' },
+    integrationConnectionNode: { kind: 'service', field: 'integrationConnectionId' },
+};
 function workflowRouter(config) {
     const router = (0, express_1.Router)();
     const Project = (0, manager_1.getModel)('projects');
     // A project has exactly one Workflow (the central canvas), stored as the single
-    // `project.workflow` object. PATCH upserts it.
-    const resolveWorkflow = (project) => project.workflow ?? null;
+    // `project.workflow` object. It defines the project: each resource is one of its nodes.
     router.get('/projects/:id/workflow', async (req, res) => {
         try {
             const auth = await config.authProvider(req);
@@ -22,55 +31,129 @@ function workflowRouter(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 access' });
-            const workflow = resolveWorkflow(project);
-            if (!workflow)
-                return res.status(404).json({ message: 'No workflow found for this project' });
-            res.json({ data: workflow, message: 'Workflow fetched successfully' });
+            res.json({ data: await (0, workflowResources_1.readWorkflow)(project), message: 'Workflow fetched successfully' });
         }
         catch (err) {
             res.status(500).json({ message: 'Failed to fetch workflow', details: err.message });
         }
     });
+    // Saves the workflow, and makes the project what it defines: a node set to an integration the
+    // project doesn't have connects it, a new API node's connection is made, and a resource whose
+    // nodes are all gone is removed. Answers the workflow and the project's lists as they are then,
+    // and what couldn't be done (its node kept as it was sent).
     router.patch('/projects/:id/workflow', async (req, res) => {
         try {
             const auth = await config.authProvider(req);
             if (!auth?.userId)
                 return res.status(401).json({ message: 'Unauthorized' });
             const projectId = req.params.id;
-            const project = await Project.findOne({ _id: projectId });
+            let project = await Project.findOne({ _id: projectId });
             if (!project || !(0, auth_1.canEditProject)(project, auth.userId)) {
                 return res.status(403).json({ message: 'Unauthorized project access' });
             }
-            const now = new Date();
-            const existing = resolveWorkflow(project); // upsert: create the single workflow if absent
-            const base = existing ?? {
-                id: (0, crypto_1.randomUUID)(),
-                name: 'Workflow',
-                description: '',
-                status: 'draft',
-                projectId,
-                nodeSchema: null,
-                createdAt: now,
-            };
-            const { name, description, status, nodeSchema } = req.body;
-            const updated = {
-                ...base,
-                id: base.id,
-                projectId,
-                name: name ?? base.name,
-                description: description ?? base.description,
-                status: status ?? base.status,
-                nodeSchema: nodeSchema !== undefined ? nodeSchema : base.nodeSchema,
-                updatedAt: now,
-            };
-            if (project.dbType === 'sql') {
-                const SqlProject = (0, manager_1.getModel)('projects', 'sql');
-                await SqlProject.update({ _id: projectId }, { workflow: updated });
+            const { name, description, status, nodeSchema, baseUpdatedAt } = req.body;
+            if (nodeSchema !== undefined) {
+                // A schema saved removes what it lacks: one that isn't a schema is never read as empty.
+                if (!isSchema(nodeSchema))
+                    return res.status(400).json({ message: 'nodeSchema is { nodes: [...], edges: [...] }' });
+                // Made on the version it was read at, always: a change saved since (a resource added from
+                // its section, its node with it) would be undone, its resource removed.
+                if (typeof baseUpdatedAt !== 'string' || Number.isNaN(new Date(baseUpdatedAt).getTime())) {
+                    return res.status(400).json({ message: "baseUpdatedAt is required: the workflow's updatedAt as it was read" });
+                }
+                const current = project.workflow?.updatedAt ? new Date(project.workflow.updatedAt).toISOString() : null;
+                if (current !== new Date(baseUpdatedAt).toISOString()) {
+                    return res.status(409).json({ message: 'The workflow changed since it was opened: open it again to see the change.', data: await (0, workflowResources_1.readWorkflow)(project) });
+                }
             }
-            else {
-                await Project.update({ _id: new mongodb_1.ObjectId(projectId) }, { $set: { workflow: updated } });
+            const changes = {
+                ...(name !== undefined && { name }), ...(description !== undefined && { description }), ...(status !== undefined && { status }),
+            };
+            const errors = [];
+            if (nodeSchema !== undefined) {
+                const before = project.workflow?.resourceNodesAt
+                    ? { nodes: project.workflow?.nodeSchema?.nodes ?? [], edges: project.workflow?.nodeSchema?.edges ?? [] }
+                    : (0, workflowResources_1.migrateSchema)(project, { nodes: project.workflow?.nodeSchema?.nodes ?? [], edges: project.workflow?.nodeSchema?.edges ?? [] });
+                const given = { nodes: nodeSchema.nodes, edges: nodeSchema.edges };
+                // One not brought yet to define the project (see migrateSchema) is, before it's compared:
+                // its resources without a node aren't removed for it.
+                const sent = project.workflow?.resourceNodesAt ? given : (0, workflowResources_1.migrateSchema)(project, given);
+                // What it would remove: a resource bound to a node before, to none now. An app connected
+                // with OAuth deletes nothing (as its DELETEs are refused), nor through the workflow.
+                const was = (0, workflowResources_1.referencedIn)(before);
+                const removing = Object.keys(was).flatMap(kind => [...was[kind]].filter(id => !(0, workflowResources_1.referencedIn)(sent)[kind].has(id)).map(id => ({ kind, id })));
+                if (req.auth?.oauth && removing.length) {
+                    const named = removing.map(({ kind, id }) => before.nodes.find((n) => n.data && Object.values(n.data).includes(id))?.data?.label ?? `${kind} ${id}`);
+                    return res.status(403).json({ message: `An app connected with OAuth removes nothing: this would remove ${named.join(', ')}`, removing });
+                }
+                // What its nodes make: the integrations they were set to, the APIs, pipelines and exports
+                // drafted on them.
+                const connected = new Map();
+                const nodes = [];
+                for (const node of sent.nodes) {
+                    let data = node?.data ?? {};
+                    const pending = INTEGRATION_KIND[node?.type];
+                    const integrationId = pending && (0, workflowResources_1.pendingOf)(data[pending.field]);
+                    if (pending && integrationId) {
+                        if (!connected.has(integrationId)) {
+                            const result = await (0, projectIntegration_1.connectIntegration)(await Project.findOne({ _id: projectId }), integrationId, auth, config, { kind: pending.kind });
+                            if ('error' in result)
+                                errors.push(`${data.label ?? integrationId}: ${result.error}`);
+                            else
+                                connected.set(integrationId, result.connection.id);
+                        }
+                        if (connected.has(integrationId))
+                            data = { ...data, [pending.field]: connected.get(integrationId) };
+                    }
+                    if (node.type === 'pipelineRefNode' && data.pipelineDraft && !data.pipelineId) {
+                        try {
+                            const pipeline = await (0, workflowResources_1.createPipelineOf)(projectId, String(data.pipelineDraft.name ?? data.label), auth.userId);
+                            const { pipelineDraft: _draft, ...rest } = data;
+                            data = { ...rest, pipelineId: pipeline.id, label: pipeline.name };
+                        }
+                        catch (err) {
+                            errors.push(`${data.pipelineDraft?.name ?? 'Pipeline'}: ${err.message}`);
+                        }
+                    }
+                    if (node.type === 'exportNode' && data.exportDraft && !data.exportId) {
+                        try {
+                            const exportName = String(data.exportDraft.name ?? data.label);
+                            const mainDb = config.databases?.find(db => db.main) ?? config.databases?.[0];
+                            const created = await (0, export_1.createExport)(config, projectId, '', exportName, mainDb?.type ?? 'nosql', 'json', false, ['*'], export_2.DEFAULT_NODE_SCHEMA, false, false, undefined);
+                            const { exportDraft: _draft, ...rest } = data;
+                            data = { ...rest, exportId: created.exportId, label: exportName };
+                        }
+                        catch (err) {
+                            errors.push(`${data.exportDraft?.name ?? 'Export'}: ${err.message}`);
+                        }
+                    }
+                    if (node.type === 'connectionNode' && data.connectionDraft && !data.connectionId) {
+                        try {
+                            const { name: apiName, apiUrl, method, token, prefix, description: apiDescription } = data.connectionDraft;
+                            const created = await (0, connection_1.addConnection)(config, projectId, { name: apiName, apiUrl, method: method ?? 'GET', token, prefix, description: apiDescription });
+                            const { connectionDraft: _draft, ...rest } = data;
+                            data = { ...rest, connectionId: created.id, label: created.name, subtitle: created.apiUrl };
+                        }
+                        catch (err) {
+                            errors.push(`${data.connectionDraft?.name ?? 'API'}: ${err.message}`);
+                        }
+                    }
+                    nodes.push(data === node?.data ? node : { ...node, data });
+                }
+                project = await Project.findOne({ _id: projectId });
+                for (const { kind, id } of removing) {
+                    try {
+                        await (0, workflowResources_1.removeResourceOf)(project, kind, id, config);
+                    }
+                    catch (err) {
+                        errors.push(`${id}: ${err.message}`);
+                    }
+                }
+                changes.nodeSchema = (0, workflowResources_1.oneNodePerResource)({ nodes, edges: sent.edges });
+                changes.resourceNodesAt = project.workflow?.resourceNodesAt ?? new Date();
             }
-            res.json({ data: updated, message: 'Workflow updated successfully' });
+            const updated = await (0, workflowResources_1.writeWorkflow)(await Project.findOne({ _id: projectId }), changes);
+            res.json({ data: updated, project: await (0, workflowResources_1.listsOf)(projectId), errors, message: 'Workflow updated successfully' });
         }
         catch (err) {
             res.status(500).json({ message: 'Failed to update workflow', details: err.message });

package/dist/models/Model.js

@@ -41,7 +41,14 @@ class Model {
                     delete processedFilter._id;
                 }
                 let sqlResults = [];
-                if (this.tableName === 'projects' && processedFilter.members && processedFilter.members.$elemMatch) {
+                if (this.tableName === 'projects' && typeof processedFilter.connectedIntegration === 'string') {
+                    // The projects one of whose connections uses an integration (its id in any of their lists).
+                    const schema = this.schema || 'streamby';
+                    const has = JSON.stringify([{ integrationId: processedFilter.connectedIntegration }]);
+                    const result = await connection.query(`SELECT * FROM "${schema}"."projects" WHERE "dbConnections" @> $1::jsonb OR "storageConnections" @> $1::jsonb OR "integrationConnections" @> $1::jsonb`, [has]);
+                    sqlResults = result.rows;
+                }
+                else if (this.tableName === 'projects' && processedFilter.members && processedFilter.members.$elemMatch) {
                     // Handle members filter for SQL projects
                     const userId = processedFilter.members.$elemMatch.userId;
                     const schema = this.schema || 'streamby'; // Default to 'streamby' if schema not provided
@@ -82,6 +89,10 @@ class Model {
                 }
             }
             else if (dbType === 'nosql') {
+                if (this.tableName === 'projects' && typeof processedFilter.connectedIntegration === 'string') {
+                    const integrationId = processedFilter.connectedIntegration;
+                    processedFilter = { $or: ['dbConnections', 'storageConnections', 'integrationConnections'].map(list => ({ [`${list}.integrationId`]: integrationId })) };
+                }
                 const nosqlResults = await nosql_1.nosqlAdapter.find(connection, this.tableName, processedFilter);
                 for (const item of nosqlResults) {
                     allResults.push(this.transformResult(item));

package/dist/services/apiTokenPermissions.d.ts

@@ -1,5 +1,5 @@
 /** Permissions on a project, for the projects a token reaches. */
-export declare const PROJECT_PERMISSIONS: readonly ["project:read", "project:update", "project:delete", "members:read", "members:manage", "assets:read", "assets:write", "assets:delete", "production:read", "production:write", "production:delete", "workflow:read", "workflow:write", "exports:read", "exports:write", "rights:read", "rights:write", "jobs:read", "jobs:run"];
+export declare const PROJECT_PERMISSIONS: readonly ["project:read", "project:update", "project:delete", "members:read", "members:manage", "assets:read", "assets:write", "assets:delete", "production:read", "production:write", "production:delete", "workflow:read", "workflow:write", "exports:read", "exports:write", "rights:read", "rights:write", "jobs:read", "jobs:run", "docs:read", "docs:write", "docs:publish", "docs:delete"];
 /** Permissions on the account: only a user's token has them. */
 export declare const ACCOUNT_PERMISSIONS: readonly ["projects:create"];
 export type ProjectPermission = typeof PROJECT_PERMISSIONS[number];

package/dist/services/apiTokenPermissions.js

@@ -15,6 +15,7 @@ exports.PROJECT_PERMISSIONS = [
     'exports:read', 'exports:write',
     'rights:read', 'rights:write',
     'jobs:read', 'jobs:run',
+    'docs:read', 'docs:write', 'docs:publish', 'docs:delete',
 ];
 /** Permissions on the account: only a user's token has them. */
 exports.ACCOUNT_PERMISSIONS = ['projects:create'];
@@ -74,7 +75,9 @@ const RULES = [
     // Rights.
     rule('read', `${P}/assets/[^/]+/rights`, 'rights:read'),
     rule(['PUT'], `${P}/assets/[^/]+/rights`, 'rights:write'),
+    rule('read', `${P}/credits-sheets(/[^/]+)?`, 'rights:read'),
     // Connections (API, database, storage, distribution, workers): the project's settings.
+    rule('read', `${P}/dependents/[^/]+/[^/]+`, 'project:read'),
     rule('read', `${P}/(connections|get-connection|distribution-connections|workers)(/.+)?`, 'project:read'),
     rule('write', `${P}/(connections|distribution-connections|workers)(/.+)?`, 'project:update'),
     rule('delete', `${P}/(connections|distribution-connections|workers)/.+`, 'project:update'),
@@ -94,6 +97,13 @@ const RULES = [
     // Jobs: transcoding, rendering, AI, publishing a deliverable.
     rule('read', `${P}/jobs`, 'jobs:read'),
     rule(['POST'], `${P}/(jobs/[^/]+(/retry)?|pipeline-suggest|deliverables/[^/]+/publish)`, 'jobs:run'),
+    // Documents: writing them is saving a version or moving them; publishing one (choosing what
+    // the exports deliver, or whether they deliver it at all) is apart. A PATCH that changes
+    // `exportable` needs docs:publish too (see routes/document).
+    rule('read', `${P}/documents(/.+)?`, 'docs:read'),
+    rule(['POST'], `${P}/documents/[^/]+/publish`, 'docs:publish'),
+    rule('write', `${P}/documents(/[^/]+(/sections)?)?`, 'docs:write'),
+    rule('delete', `${P}/documents/[^/]+`, 'docs:delete'),
 ];
 /** The rule for a request made with an API token, or undefined: not reachable with one. */
 function routeRuleFor(method, path) {

package/dist/services/auth.d.ts

@@ -8,5 +8,7 @@ export declare const scopeReachesProject: (scope: Auth["apiToken"], projectId: s
 export declare const tokenAllows: (scope: Auth["apiToken"], permission: ApiTokenPermission) => boolean;
 /** Whether an app (an OAuth request) may make this request's method on its path. */
 export declare const oauthMayDelete: (method: string, path: string) => boolean;
+/** Whether a request publishes a document (its version, or whether it's exported). */
+export declare const publishesDocument: (method: string, path: string, body: unknown) => boolean;
 export declare const enforceApiTokenScope: (req: Request, res: Response, next: NextFunction) => void | Response<any, Record<string, any>>;
 export declare const authenticate: (config: StreamByConfig) => (req: Request, res: Response, next: NextFunction) => Promise<void | Response<any, Record<string, any>>>;

package/dist/services/auth.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.authenticate = exports.enforceApiTokenScope = exports.oauthMayDelete = exports.tokenAllows = exports.scopeReachesProject = exports.isPublicRoute = void 0;
+exports.authenticate = exports.enforceApiTokenScope = exports.publishesDocument = exports.oauthMayDelete = exports.tokenAllows = exports.scopeReachesProject = exports.isPublicRoute = void 0;
 const auth_1 = require("../utils/auth");
 const apiTokenPermissions_1 = require("./apiTokenPermissions");
 const oauthTokens_1 = require("./oauthTokens");
@@ -46,6 +46,19 @@ const OAUTH_DELETE_ALLOWED = new RegExp(`^/projects/[^/]+/deliverables/[^/]+/?$`
 /** Whether an app (an OAuth request) may make this request's method on its path. */
 const oauthMayDelete = (method, path) => method.toUpperCase() !== 'DELETE' || OAUTH_DELETE_ALLOWED.test(path);
 exports.oauthMayDelete = oauthMayDelete;
+// Nor does an app publish: what it edits stays a draft until someone publishes it. Publishing
+// is choosing a document's version for its exports (POST .../publish) or whether they deliver
+// it (`exportable`). Refused whatever its scopes grant, as deleting is.
+const DOCUMENT_PUBLISH = /^\/projects\/[^/]+\/documents\/[^/]+\/publish\/?$/;
+const DOCUMENT = /^\/projects\/[^/]+\/documents\/[^/]+\/?$/;
+/** Whether a request publishes a document (its version, or whether it's exported). */
+const publishesDocument = (method, path, body) => {
+    const upper = method.toUpperCase();
+    if (upper === 'POST' && DOCUMENT_PUBLISH.test(path))
+        return true;
+    return upper === 'PATCH' && DOCUMENT.test(path) && typeof body === 'object' && body !== null && 'exportable' in body;
+};
+exports.publishesDocument = publishesDocument;
 const enforceApiTokenScope = (req, res, next) => {
     const auth = req.auth;
     const scope = auth?.apiToken;
@@ -57,6 +70,9 @@ const enforceApiTokenScope = (req, res, next) => {
     if (auth?.oauth && !(0, exports.oauthMayDelete)(req.method, req.path)) {
         return res.status(403).json({ error: 'An app connected with OAuth can\'t delete' });
     }
+    if (auth?.oauth && (0, exports.publishesDocument)(req.method, req.path, req.body)) {
+        return res.status(403).json({ error: 'An app connected with OAuth can\'t publish: what it edits stays a draft' });
+    }
     const rule = (0, apiTokenPermissions_1.routeRuleFor)(req.method, req.path);
     if (!rule || (rule.userTokenOnly && scope.kind !== 'user')) {
         return res.status(403).json({ error: 'Not available with an API token' });

package/dist/services/creditsSheets.d.ts

@@ -0,0 +1,39 @@
+import { ProjectDocument } from '../types';
+import { LicenseType } from './rights';
+export declare const CREDITS_SHEET_NODE = "creditsSheetNode";
+export interface SheetSources {
+    assetIds: string[];
+    folderIds: string[];
+}
+declare const REQUIRED: readonly ["creatorName", "sourceUrl", "licenseType"];
+type Required = typeof REQUIRED[number];
+export type RowSource = 'asset' | 'folder' | 'ingest';
+export interface SheetRow {
+    assetId: string;
+    name: string;
+    category: string | null;
+    sourceUrl: string | null;
+    creatorName: string | null;
+    creatorUrl: string | null;
+    licenseType: LicenseType | null;
+    comments: string | null;
+    missing: Required[];
+    from: RowSource[];
+}
+export type SheetStatus = 'complete' | 'incomplete';
+export interface CreditsSheet {
+    document: ProjectDocument;
+    sources: SheetSources;
+    rows: SheetRow[];
+    status: SheetStatus;
+}
+/** A sheet's content as it's saved: its sources, as JSON. */
+export declare function checkSheetContent(value: unknown): string | {
+    error: string;
+};
+export declare function sheetSources(document: Pick<ProjectDocument, 'content'>): SheetSources;
+/** The assets imported by the Ingest nodes connected (either way) to the sheet's node. */
+export declare function ingestAssetsOf(workflow: any, documentId: string): string[];
+/** A sheet as it reads now: its rows, from its sources and its assets' metadata, and its status. */
+export declare function readSheet(project: any, document: ProjectDocument): Promise<CreditsSheet>;
+export {};

package/dist/services/creditsSheets.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CREDITS_SHEET_NODE = void 0;
+exports.checkSheetContent = checkSheetContent;
+exports.sheetSources = sheetSources;
+exports.ingestAssetsOf = ingestAssetsOf;
+exports.readSheet = readSheet;
+const nosqlDb_1 = require("../utils/nosqlDb");
+const rights_1 = require("./rights");
+// A credits sheet: a project document (kind 'credits') that a Credits sheet node of the
+// workflow made, listing the assets fed to it with their license metadata. It keeps only what
+// feeds it, never a copy of the metadata: assets and Storage folders picked on it (its content),
+// and the Ingest nodes connected to its node (the asset each imports). Its rows are made each
+// time it's read, from each asset's metadata, so every sheet shows the same, current, values.
+exports.CREDITS_SHEET_NODE = 'creditsSheetNode';
+// What a sheet needs of each asset to credit it.
+const REQUIRED = ['creatorName', 'sourceUrl', 'licenseType'];
+const ids = (value) => Array.isArray(value) ? [...new Set(value.filter((v) => typeof v === 'string' && !!v.trim()))] : null;
+/** A sheet's content as it's saved: its sources, as JSON. */
+function checkSheetContent(value) {
+    if (value === undefined || value === '')
+        return JSON.stringify({ assetIds: [], folderIds: [] });
+    let parsed;
+    try {
+        parsed = typeof value === 'string' ? JSON.parse(value) : value;
+    }
+    catch {
+        return { error: 'A credits sheet\'s content is its sources, as JSON: { "assetIds": [...], "folderIds": [...] }' };
+    }
+    const assetIds = ids(parsed?.assetIds ?? []);
+    const folderIds = ids(parsed?.folderIds ?? []);
+    if (!assetIds || !folderIds)
+        return { error: 'assetIds and folderIds are lists of ids' };
+    return JSON.stringify({ assetIds, folderIds });
+}
+function sheetSources(document) {
+    try {
+        const parsed = JSON.parse(document.content || '{}');
+        return { assetIds: ids(parsed.assetIds) ?? [], folderIds: ids(parsed.folderIds) ?? [] };
+    }
+    catch {
+        return { assetIds: [], folderIds: [] };
+    }
+}
+/** The assets imported by the Ingest nodes connected (either way) to the sheet's node. */
+function ingestAssetsOf(workflow, documentId) {
+    const nodes = Array.isArray(workflow?.nodeSchema?.nodes) ? workflow.nodeSchema.nodes : [];
+    const edges = Array.isArray(workflow?.nodeSchema?.edges) ? workflow.nodeSchema.edges : [];
+    const sheetNodes = new Set(nodes.filter(n => n?.type === exports.CREDITS_SHEET_NODE && n.data?.documentId === documentId).map(n => n.id));
+    const byId = new Map(nodes.map(n => [n?.id, n]));
+    const found = [];
+    for (const edge of edges) {
+        const other = sheetNodes.has(edge?.target) ? edge.source : sheetNodes.has(edge?.source) ? edge.target : null;
+        const node = other != null ? byId.get(other) : null;
+        if (node?.type === 'ingestNode' && typeof node.data?.fileId === 'string' && node.data.fileId)
+            found.push(node.data.fileId);
+    }
+    return [...new Set(found)];
+}
+// The folders given and every folder inside them.
+async function withSubfolders(db, projectId, folderIds) {
+    if (!folderIds.length)
+        return [];
+    const all = await db.collection('storage_folders').find({ projectId }).toArray();
+    const children = new Map();
+    for (const f of all) {
+        if (f.parentId)
+            children.set(f.parentId, [...(children.get(f.parentId) ?? []), f.folderId]);
+    }
+    const found = new Set();
+    const queue = folderIds.filter(id => all.some(f => f.folderId === id));
+    while (queue.length) {
+        const id = queue.shift();
+        if (found.has(id))
+            continue;
+        found.add(id);
+        queue.push(...(children.get(id) ?? []));
+    }
+    return [...found];
+}
+const missingOf = (rights) => REQUIRED.filter(field => !rights?.[field]);
+/** A sheet as it reads now: its rows, from its sources and its assets' metadata, and its status. */
+async function readSheet(project, document) {
+    const projectId = String(project._id ?? project.id);
+    const sources = sheetSources(document);
+    const db = (0, nosqlDb_1.nosqlDb)();
+    const order = sources.assetIds.map(assetId => ({ assetId, from: 'asset' }));
+    let files = [];
+    if (db) {
+        const folders = await withSubfolders(db, projectId, sources.folderIds);
+        if (folders.length) {
+            const inFolders = await db.collection('storage_files').find({ projectId, folderId: { $in: folders } }).toArray();
+            order.push(...inFolders.map(f => ({ assetId: f.fileId, from: 'folder' })));
+        }
+        order.push(...ingestAssetsOf(project.workflow, document.id).map(assetId => ({ assetId, from: 'ingest' })));
+        const wanted = [...new Set(order.map(o => o.assetId))];
+        files = wanted.length ? await db.collection('storage_files').find({ projectId, fileId: { $in: wanted } }).toArray() : [];
+    }
+    // An asset deleted is no longer in Storage: it leaves the sheet.
+    const fileOf = new Map(files.map(f => [f.fileId, f]));
+    const rights = await (0, rights_1.getRightsOf)(projectId, [...fileOf.keys()]);
+    const rows = new Map();
+    for (const { assetId, from } of order) {
+        const file = fileOf.get(assetId);
+        if (!file)
+            continue;
+        const row = rows.get(assetId);
+        if (row) {
+            if (!row.from.includes(from))
+                row.from.push(from);
+            continue;
+        }
+        const r = rights.get(assetId);
+        rows.set(assetId, {
+            assetId,
+            name: file.displayName ?? assetId,
+            category: file.category ?? null,
+            sourceUrl: r?.sourceUrl ?? null,
+            creatorName: r?.creatorName ?? null,
+            creatorUrl: r?.creatorUrl ?? null,
+            licenseType: r?.licenseType ?? null,
+            comments: r?.comments ?? null,
+            missing: missingOf(r),
+            from: [from],
+        });
+    }
+    const list = [...rows.values()];
+    return { document, sources, rows: list, status: list.length && list.every(r => !r.missing.length) ? 'complete' : 'incomplete' };
+}

package/dist/services/dependents.d.ts

@@ -0,0 +1,11 @@
+export type ResourceKind = 'db' | 'api' | 'storage' | 'service' | 'export' | 'pipeline';
+export declare const RESOURCE_KINDS: ResourceKind[];
+export interface Dependent {
+    type: 'workflow' | 'export' | 'pipeline' | 'files' | 'folders' | 'deliverables' | 'shots';
+    name: string;
+    id?: string;
+    count?: number;
+}
+/** The resource of that kind in the project, if it has it. */
+export declare function findResource(project: any, kind: ResourceKind, id: string): any | null;
+export declare function dependentsOf(project: any, kind: ResourceKind, id: string): Promise<Dependent[]>;

package/dist/services/dependents.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RESOURCE_KINDS = void 0;
+exports.findResource = findResource;
+exports.dependentsOf = dependentsOf;
+const nosqlDb_1 = require("../utils/nosqlDb");
+const workflowResources_1 = require("./workflowResources");
+exports.RESOURCE_KINDS = ['db', 'api', 'storage', 'service', 'export', 'pipeline'];
+// The node data fields that point at each kind of resource.
+const FIELDS = {
+    db: ['connectionId'],
+    api: ['connectionId'],
+    storage: ['storageConnectionId'],
+    service: ['integrationConnectionId'],
+    export: ['exportId'],
+    pipeline: ['pipelineId'],
+};
+// A resource's own node in the workflow isn't a dependent of it: its other nodes using it are
+// (a data source reading one of a database's tables, an Ingest importing one file).
+const ownNode = (node, kind, id) => (0, workflowResources_1.isOwnNode)(node, kind, id);
+const nodesUsing = (schema, kind, id, skipOwn = false) => (Array.isArray(schema?.nodes) ? schema.nodes : []).filter((node) => !(skipOwn && ownNode(node, kind, id))
+    && FIELDS[kind].some(field => node?.data?.[field] === id));
+const labels = (nodes) => [...new Set(nodes.map(n => n?.data?.label || n?.type).filter(Boolean))].join(', ');
+/** The resource of that kind in the project, if it has it. */
+function findResource(project, kind, id) {
+    const list = {
+        db: project.dbConnections, api: project.connections, storage: project.storageConnections,
+        service: project.integrationConnections, export: project.exports, pipeline: project.pipelines,
+    }[kind] ?? [];
+    return list.find((r) => String(r.id) === id) ?? null;
+}
+// A storage connection's files: a built-in one's older files were stamped with the provider's
+// id, or with nothing (see routes/storage's connFilter).
+const filesOf = (projectId, conn) => conn?.source === 'builtin'
+    ? { projectId, $or: [{ storageConnectionId: conn.id }, { storageConnectionId: conn.integrationId }, { storageConnectionId: { $exists: false } }] }
+    : { projectId, storageConnectionId: conn.id };
+async function dependentsOf(project, kind, id) {
+    const projectId = String(project._id ?? project.id);
+    const found = [];
+    const inWorkflow = nodesUsing(project.workflow?.nodeSchema, kind, id, true);
+    if (inWorkflow.length)
+        found.push({ type: 'workflow', name: labels(inWorkflow), count: inWorkflow.length });
+    for (const exp of project.exports ?? []) {
+        if (kind === 'export' && String(exp.id) === id)
+            continue;
+        const nodes = nodesUsing(exp.nodeSchema, kind, id);
+        if (nodes.length)
+            found.push({ type: 'export', id: String(exp.id), name: exp.name ?? String(exp.id), count: nodes.length });
+    }
+    const db = (0, nosqlDb_1.nosqlDb)();
+    if (!db)
+        return found;
+    const pipelines = await db.collection('pipelines').find({ projectId }).toArray();
+    for (const pipeline of pipelines) {
+        if (kind === 'pipeline' && pipeline.id === id)
+            continue;
+        const nodes = nodesUsing(pipeline.nodeSchema, kind, id);
+        if (nodes.length)
+            found.push({ type: 'pipeline', id: pipeline.id, name: pipeline.name ?? pipeline.id, count: nodes.length });
+    }
+    if (kind === 'storage') {
+        const conn = findResource(project, 'storage', id);
+        if (conn) {
+            const files = await db.collection('storage_files').countDocuments(filesOf(projectId, conn));
+            if (files)
+                found.push({ type: 'files', name: 'Files', count: files });
+            const folders = await db.collection('storage_folders').countDocuments(filesOf(projectId, conn));
+            if (folders)
+                found.push({ type: 'folders', name: 'Folders', count: folders });
+        }
+    }
+    if (kind === 'export') {
+        const deliverables = await db.collection('deliverables').countDocuments({ projectId, exportId: id });
+        if (deliverables)
+            found.push({ type: 'deliverables', name: 'Deliverables', count: deliverables });
+        const shots = await db.collection('production_shots').countDocuments({ projectId, exportId: id });
+        if (shots)
+            found.push({ type: 'shots', name: 'Shots', count: shots });
+    }
+    return found;
+}

package/dist/services/documents.d.ts

@@ -0,0 +1,66 @@
+import { Auth, DocumentAuthor, DocumentVersion, ProjectDocument, StreamByConfig } from '../types';
+/** A document as the tree lists it: all but its content. */
+export type DocumentSummary = Omit<ProjectDocument, 'content'>;
+/** A version as the history lists it: all but its content. */
+export type VersionSummary = Omit<DocumentVersion, 'content'>;
+type Structure = Partial<Pick<ProjectDocument, 'parentId' | 'position' | 'exportable' | 'publishedVersion'>>;
+export interface DocumentStore {
+    list(projectId: string): Promise<DocumentSummary[]>;
+    get(projectId: string, id: string): Promise<ProjectDocument | null>;
+    /** A new document, and its first version. */
+    create(document: ProjectDocument): Promise<ProjectDocument>;
+    /**
+     * A new version, only if the document is still at `baseVersion`: null if it isn't (someone
+     * saved in between) or there's no such document.
+     */
+    save(projectId: string, id: string, baseVersion: number, change: {
+        title: string;
+        content: string;
+    }, author: DocumentAuthor, at: Date): Promise<ProjectDocument | null>;
+    /** Where it is in the tree, and what's published of it: not a version. */
+    update(projectId: string, id: string, patch: Structure): Promise<ProjectDocument | null>;
+    /** Its versions, the latest first. */
+    versions(projectId: string, id: string): Promise<VersionSummary[]>;
+    version(projectId: string, id: string, version: number): Promise<DocumentVersion | null>;
+    /** Documents and their versions. */
+    remove(projectId: string, ids: string[]): Promise<void>;
+    /** A deleted project's documents. */
+    deleteProject(projectId: string): Promise<void>;
+}
+/** The router's main database, where documents are kept. */
+export declare const setDocumentStoreDatabase: (config: StreamByConfig) => void;
+export declare function documentStore(): DocumentStore;
+/** Who's saving: the user, through the UI, an API token, or an app acting for them. */
+export declare function authorOf(auth: Auth): DocumentAuthor;
+/** A document and everything inside it (a folder's documents, at any depth). */
+export declare function withDescendants(documents: DocumentSummary[], id: string): string[];
+export type SectionResult = {
+    content: string;
+} | {
+    error: 'not-found' | 'ambiguous';
+};
+/**
+ * The markdown with what's under `heading` replaced by `body`, the rest untouched. `heading` is
+ * its title, with or without its #s ("## Architecture", "Architecture"): with them, only a
+ * heading of that level matches.
+ */
+export declare function replaceSection(markdown: string, heading: string, body: string): SectionResult;
+/** A document as an export delivers it: its published version, never a draft. */
+export interface PublishedDocument {
+    id: string;
+    title: string;
+    parentId: string | null;
+    position: number;
+    version: number;
+    content: string;
+    publishedAt: Date;
+}
+/**
+ * The project's exportable documents that have a published version (in one folder, at any
+ * depth, or only those given), as that version was saved.
+ */
+export declare function publishedDocuments(projectId: string, scope?: {
+    folderId?: string;
+    documentIds?: string[];
+}): Promise<PublishedDocument[]>;
+export {};