streamby-core 0.42.0 → 0.43.1

package/dist/middleware/routes/userIntegration.js

@@ -2,9 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.userIntegrationRouter = userIntegrationRouter;
 const express_1 = require("express");
+const workflowResources_1 = require("../../services/workflowResources");
 const builtinAccess_1 = require("../../utils/builtinAccess");
 const userIntegration_1 = require("../../services/userIntegration");
 const sanitize_1 = require("../../utils/sanitize");
+const manager_1 = require("../../models/manager");
 const VALID_KINDS = ['database', 'storage', 'service'];
 const VALID_DB_PROVIDERS = ['postgresql', 'mongodb'];
 const VALID_STORAGE_PROVIDERS = ['s3', 'gcs', 'r2', 'azure'];
@@ -91,6 +93,29 @@ function userIntegrationRouter(config) {
             res.status(500).json({ message: 'Failed to update integration', details: err.message });
         }
     });
+    // The projects' connections that use one of the user's integrations: a connection can't
+    // work without it, so deleting it disconnects them.
+    const LISTS = [['dbConnections', 'db'], ['storageConnections', 'storage'], ['integrationConnections', 'service']];
+    async function connectionsUsing(integrationId) {
+        // Only the projects using it, asked of the database (not every project, read and filtered).
+        const projects = await (0, manager_1.getModel)('projects').find({ connectedIntegration: integrationId });
+        return projects.flatMap(project => LISTS.flatMap(([list, kind]) => (project[list] ?? [])
+            .filter(c => c.integrationId === integrationId && c.source !== 'builtin')
+            .map(c => ({ projectId: String(project._id ?? project.id), projectName: project.name, kind, list, connectionId: c.id, name: c.name }))));
+    }
+    router.get('/user/integrations/:integrationId/dependents', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const integration = await (0, manager_1.getModel)('user_integrations').findOne({ id: req.params.integrationId, userId: auth.userId });
+            if (!integration)
+                return res.status(404).json({ message: 'Integration not found' });
+            const found = await connectionsUsing(req.params.integrationId);
+            res.json({ dependents: found.map(({ list: _list, ...d }) => d) });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
     // ─── Delete ────────────────────────────────────────────────────────────────
     router.delete('/user/integrations/:integrationId', async (req, res) => {
         try {
@@ -98,7 +123,23 @@ function userIntegrationRouter(config) {
             const deleted = await (0, userIntegration_1.deleteUserIntegration)(auth.userId, req.params.integrationId);
             if (!deleted)
                 return res.status(404).json({ message: 'Integration not found' });
-            res.json({ message: 'Integration deleted' });
+            const Project = (0, manager_1.getModel)('projects');
+            const disconnected = await connectionsUsing(req.params.integrationId);
+            for (const c of disconnected) {
+                await Project.update({ _id: c.projectId }, { $pull: { [c.list]: { id: c.connectionId } } });
+                await (0, workflowResources_1.removeFromWorkflow)(c.projectId, c.kind, c.connectionId);
+            }
+            // Each project it was disconnected from, with its connections as they are now.
+            const affected = await Promise.all([...new Set(disconnected.map(c => c.projectId))].map(async (projectId) => {
+                const project = await Project.findOne({ _id: projectId });
+                return {
+                    projectId,
+                    dbConnections: (0, sanitize_1.sanitizeConnections)(project?.dbConnections),
+                    storageConnections: (0, sanitize_1.sanitizeConnections)(project?.storageConnections),
+                    integrationConnections: (0, sanitize_1.sanitizeConnections)(project?.integrationConnections),
+                };
+            }));
+            res.json({ message: 'Integration deleted', disconnected: disconnected.length, affected });
         }
         catch (err) {
             res.status(500).json({ message: 'Failed to delete integration', details: err.message });

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,26 +41,12 @@ class Model {
                     delete processedFilter._id;
                 }
                 let sqlResults = [];
-                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
-                    const query = `
-            SELECT p.*, pm."userId" as memberUserId, pm.role as memberRole, pm.status as memberStatus, pm.archived as memberArchived
-            FROM "${schema}"."projects" p
-            JOIN "${schema}"."project_members" pm ON p.id = pm."projectId"
-            WHERE pm."userId" = $1
-          `;
-                    const result = await connection.query(query, [userId]);
-                    sqlResults = result.rows.map(row => ({
-                        ...row,
-                        members: [{
-                                userId: row.memberUserId,
-                                role: row.memberRole,
-                                status: row.memberStatus,
-                                archived: row.memberArchived,
-                            }]
-                    }));
+                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 {
                     // General SQL find
@@ -69,19 +55,24 @@ class Model {
                 for (const item of sqlResults) {
                     const transformedItem = this.transformResult(item);
                     if (this.tableName === 'projects' && !transformedItem.members) {
-                        // For projects, if members not already populated by join, fetch from project_members table
+                        // A SQL project's members are rows of project_members, read with it
                         const projectMembers = await sql_1.sqlAdapter.find(connection, 'project_members', { projectId: transformedItem.id }, this.schema);
                         transformedItem.members = projectMembers.map((member) => ({
                             userId: member.userId,
                             role: member.role,
                             status: member.status,
                             archived: member.archived,
+                            ...(member.invitedBy ? { invitedBy: member.invitedBy } : {}),
                         }));
                     }
                     allResults.push(transformedItem);
                 }
             }
             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));
@@ -127,6 +118,7 @@ class Model {
                             role: member.role,
                             status: member.status,
                             archived: member.archived,
+                            ...(member.invitedBy ? { invitedBy: member.invitedBy } : {}),
                         }));
                     }
                     // Track which connection found this record so update() routes correctly

package/dist/services/apiTokenPermissions.js

@@ -75,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'),

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/production.d.ts

@@ -1,2 +1,2 @@
-/** A deleted project's sequences, shots, tasks and deliverables: only that project's. */
+/** A deleted project's sequences, shots, tasks, deliverables and its assets' license metadata: only that project's. */
 export declare function deleteProductionData(projectId: string): Promise<void>;

package/dist/services/production.js

@@ -2,12 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.deleteProductionData = deleteProductionData;
 const nosqlDb_1 = require("../utils/nosqlDb");
-/** A deleted project's sequences, shots, tasks and deliverables: only that project's. */
+/** A deleted project's sequences, shots, tasks, deliverables and its assets' license metadata: only that project's. */
 async function deleteProductionData(projectId) {
     const db = (0, nosqlDb_1.nosqlDb)();
     if (!db || !projectId)
         return;
-    for (const name of ['production_tasks', 'production_shots', 'production_sequences', 'deliverables']) {
+    for (const name of ['production_tasks', 'production_shots', 'production_sequences', 'deliverables', 'asset_rights']) {
         await db.collection(name).deleteMany({ projectId });
     }
 }