streamby-core 0.41.0 → 0.43.0

package/dist/services/documents.js

@@ -0,0 +1,347 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setDocumentStoreDatabase = void 0;
+exports.documentStore = documentStore;
+exports.authorOf = authorOf;
+exports.withDescendants = withDescendants;
+exports.replaceSection = replaceSection;
+exports.publishedDocuments = publishedDocuments;
+const connectionManager_1 = require("../adapters/database/connectionManager");
+const withoutContent = ({ content: _content, ...rest }) => rest;
+const byPlace = (a, b) => a.position - b.position || new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime();
+// ── PostgreSQL ──
+const sqlStore = (pool) => {
+    const DOCS = 'streamby.documents';
+    const VERSIONS = 'streamby.document_versions';
+    const SUMMARY = `id, "projectId", kind, title, "parentId", position, version, exportable, "publishedVersion", "createdAt", "createdBy", "updatedAt", "updatedBy"`;
+    const insertVersion = (client, v) => client.query(`INSERT INTO ${VERSIONS} ("documentId", "projectId", version, title, content, author, "createdAt") VALUES ($1, $2, $3, $4, $5, $6, $7)`, [v.documentId, v.projectId, v.version, v.title, v.content, JSON.stringify(v.author), v.createdAt]);
+    // A save changes two tables: both, or neither.
+    const transaction = async (work) => {
+        const client = await pool.connect();
+        try {
+            await client.query('BEGIN');
+            const result = await work(client);
+            await client.query(result === null ? 'ROLLBACK' : 'COMMIT');
+            return result;
+        }
+        catch (err) {
+            await client.query('ROLLBACK').catch(() => { });
+            throw err;
+        }
+        finally {
+            client.release();
+        }
+    };
+    return {
+        async list(projectId) {
+            const { rows } = await pool.query(`SELECT ${SUMMARY} FROM ${DOCS} WHERE "projectId" = $1 ORDER BY position, "createdAt"`, [projectId]);
+            return rows;
+        },
+        async get(projectId, id) {
+            const { rows } = await pool.query(`SELECT * FROM ${DOCS} WHERE "projectId" = $1 AND id = $2`, [projectId, id]);
+            return rows[0] ?? null;
+        },
+        async create(d) {
+            return (await transaction(async (client) => {
+                const { rows } = await client.query(`INSERT INTO ${DOCS} (id, "projectId", kind, title, "parentId", position, content, version, exportable, "publishedVersion", "createdAt", "createdBy", "updatedAt", "updatedBy")
+           VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14) RETURNING *`, [d.id, d.projectId, d.kind, d.title, d.parentId, d.position, d.content, d.version, d.exportable, d.publishedVersion,
+                    d.createdAt, JSON.stringify(d.createdBy), d.updatedAt, JSON.stringify(d.updatedBy)]);
+                await insertVersion(client, { documentId: d.id, projectId: d.projectId, version: d.version, title: d.title, content: d.content, author: d.createdBy, createdAt: d.createdAt });
+                return rows[0];
+            }));
+        },
+        async save(projectId, id, baseVersion, change, author, at) {
+            return transaction(async (client) => {
+                const { rows } = await client.query(`UPDATE ${DOCS} SET title = $4, content = $5, version = version + 1, "updatedAt" = $6, "updatedBy" = $7
+            WHERE "projectId" = $1 AND id = $2 AND version = $3 RETURNING *`, [projectId, id, baseVersion, change.title, change.content, at, JSON.stringify(author)]);
+                const saved = rows[0];
+                if (!saved)
+                    return null;
+                await insertVersion(client, { documentId: id, projectId, version: saved.version, title: saved.title, content: saved.content, author, createdAt: at });
+                return saved;
+            });
+        },
+        async update(projectId, id, patch) {
+            const entries = Object.entries(patch).filter(([, value]) => value !== undefined);
+            if (!entries.length)
+                return this.get(projectId, id);
+            const sets = entries.map(([key], i) => `"${key}" = $${i + 3}`).join(', ');
+            const { rows } = await pool.query(`UPDATE ${DOCS} SET ${sets} WHERE "projectId" = $1 AND id = $2 RETURNING *`, [projectId, id, ...entries.map(([, value]) => value)]);
+            return rows[0] ?? null;
+        },
+        async versions(projectId, id) {
+            const { rows } = await pool.query(`SELECT "documentId", "projectId", version, title, author, "createdAt" FROM ${VERSIONS}
+          WHERE "projectId" = $1 AND "documentId" = $2 ORDER BY version DESC`, [projectId, id]);
+            return rows;
+        },
+        async version(projectId, id, version) {
+            const { rows } = await pool.query(`SELECT * FROM ${VERSIONS} WHERE "projectId" = $1 AND "documentId" = $2 AND version = $3`, [projectId, id, version]);
+            return rows[0] ?? null;
+        },
+        async remove(projectId, ids) {
+            if (!ids.length)
+                return;
+            await transaction(async (client) => {
+                await client.query(`DELETE FROM ${VERSIONS} WHERE "projectId" = $1 AND "documentId" = ANY($2)`, [projectId, ids]);
+                await client.query(`DELETE FROM ${DOCS} WHERE "projectId" = $1 AND id = ANY($2)`, [projectId, ids]);
+                return true;
+            });
+        },
+        async deleteProject(projectId) {
+            await pool.query(`DELETE FROM ${VERSIONS} WHERE "projectId" = $1`, [projectId]);
+            await pool.query(`DELETE FROM ${DOCS} WHERE "projectId" = $1`, [projectId]);
+        },
+    };
+};
+// ── MongoDB ──
+// A save writes the document and then its version: in a transaction, both or neither, when
+// the server supports them (a replica set or a sharded cluster, as Atlas is). A standalone
+// server doesn't: there they're two writes, and if the version's failed after the document's,
+// the document would be at a version its history lacks.
+let mongoTransactions;
+const noTransactions = (err) => {
+    const { code, message } = (err ?? {});
+    return code === 20 || /Transaction numbers are only allowed|replica set/i.test(message ?? '');
+};
+const mongoStore = (client) => {
+    const docs = () => client.db().collection('documents');
+    const versions = () => client.db().collection('document_versions');
+    const strip = (doc) => {
+        if (!doc)
+            return null;
+        const { _id, ...rest } = doc;
+        return rest;
+    };
+    const together = async (work) => {
+        if (mongoTransactions !== false && typeof client.startSession === 'function') {
+            const session = client.startSession();
+            try {
+                let result;
+                await session.withTransaction(async () => { result = await work(session); });
+                mongoTransactions = true;
+                return result;
+            }
+            catch (err) {
+                if (!noTransactions(err))
+                    throw err;
+                mongoTransactions = false;
+            }
+            finally {
+                await session.endSession();
+            }
+        }
+        return work();
+    };
+    return {
+        async list(projectId) {
+            const found = await docs().find({ projectId }, { projection: { content: 0 } }).toArray();
+            return found.map(d => strip(d)).sort(byPlace);
+        },
+        async get(projectId, id) {
+            return strip(await docs().findOne({ projectId, id }));
+        },
+        async create(d) {
+            return together(async (session) => {
+                await docs().insertOne({ ...d }, { session });
+                await versions().insertOne({ documentId: d.id, projectId: d.projectId, version: d.version, title: d.title, content: d.content, author: d.createdBy, createdAt: d.createdAt }, { session });
+                return d;
+            });
+        },
+        async save(projectId, id, baseVersion, change, author, at) {
+            return together(async (session) => {
+                // Conditional on the version: of two saves made on the same one, only the first goes through.
+                const saved = strip(await docs().findOneAndUpdate({ projectId, id, version: baseVersion }, { $set: { ...change, version: baseVersion + 1, updatedAt: at, updatedBy: author } }, { returnDocument: 'after', session }));
+                if (!saved)
+                    return null;
+                await versions().insertOne({ documentId: id, projectId, version: saved.version, ...change, author, createdAt: at }, { session });
+                return saved;
+            });
+        },
+        async update(projectId, id, patch) {
+            const $set = Object.fromEntries(Object.entries(patch).filter(([, value]) => value !== undefined));
+            if (!Object.keys($set).length)
+                return this.get(projectId, id);
+            return strip(await docs().findOneAndUpdate({ projectId, id }, { $set }, { returnDocument: 'after' }));
+        },
+        async versions(projectId, id) {
+            const found = await versions().find({ projectId, documentId: id }, { projection: { content: 0 } }).toArray();
+            return found.map(v => strip(v)).sort((a, b) => b.version - a.version);
+        },
+        async version(projectId, id, version) {
+            return strip(await versions().findOne({ projectId, documentId: id, version }));
+        },
+        async remove(projectId, ids) {
+            if (!ids.length)
+                return;
+            await together(async (session) => {
+                await versions().deleteMany({ projectId, documentId: { $in: ids } }, { session });
+                await docs().deleteMany({ projectId, id: { $in: ids } }, { session });
+            });
+        },
+        async deleteProject(projectId) {
+            await versions().deleteMany({ projectId });
+            await docs().deleteMany({ projectId });
+        },
+    };
+};
+// ── In memory (no main database) ──
+const memoryStore = () => {
+    const docs = new Map();
+    const versions = [];
+    const own = (projectId, id) => {
+        const d = docs.get(id);
+        return d && d.projectId === projectId ? d : undefined;
+    };
+    return {
+        async list(projectId) {
+            return [...docs.values()].filter(d => d.projectId === projectId).map(withoutContent).sort(byPlace);
+        },
+        async get(projectId, id) {
+            const d = own(projectId, id);
+            return d ? { ...d } : null;
+        },
+        async create(d) {
+            docs.set(d.id, { ...d });
+            versions.push({ documentId: d.id, projectId: d.projectId, version: d.version, title: d.title, content: d.content, author: d.createdBy, createdAt: d.createdAt });
+            return { ...d };
+        },
+        async save(projectId, id, baseVersion, change, author, at) {
+            const d = own(projectId, id);
+            if (!d || d.version !== baseVersion)
+                return null;
+            Object.assign(d, change, { version: baseVersion + 1, updatedAt: at, updatedBy: author });
+            versions.push({ documentId: id, projectId, version: d.version, ...change, author, createdAt: at });
+            return { ...d };
+        },
+        async update(projectId, id, patch) {
+            const d = own(projectId, id);
+            if (!d)
+                return null;
+            Object.assign(d, Object.fromEntries(Object.entries(patch).filter(([, value]) => value !== undefined)));
+            return { ...d };
+        },
+        async versions(projectId, id) {
+            return versions.filter(v => v.projectId === projectId && v.documentId === id).map(withoutContent).sort((a, b) => b.version - a.version);
+        },
+        async version(projectId, id, version) {
+            const v = versions.find(x => x.projectId === projectId && x.documentId === id && x.version === version);
+            return v ? { ...v } : null;
+        },
+        async remove(projectId, ids) {
+            for (const id of ids)
+                if (own(projectId, id))
+                    docs.delete(id);
+            for (let i = versions.length - 1; i >= 0; i--)
+                if (versions[i].projectId === projectId && ids.includes(versions[i].documentId))
+                    versions.splice(i, 1);
+        },
+        async deleteProject(projectId) {
+            for (const [id, d] of docs)
+                if (d.projectId === projectId)
+                    docs.delete(id);
+            for (let i = versions.length - 1; i >= 0; i--)
+                if (versions[i].projectId === projectId)
+                    versions.splice(i, 1);
+        },
+    };
+};
+let mainDbId;
+let memory;
+/** The router's main database, where documents are kept. */
+const setDocumentStoreDatabase = (config) => {
+    mainDbId = config.databases?.find(db => db.main)?.id;
+};
+exports.setDocumentStoreDatabase = setDocumentStoreDatabase;
+function documentStore() {
+    if (mainDbId && (0, connectionManager_1.getConnectedIds)().includes(mainDbId)) {
+        const entry = (0, connectionManager_1.getConnection)(mainDbId);
+        return entry.type === 'sql' ? sqlStore(entry.client) : mongoStore(entry.client);
+    }
+    return (memory ?? (memory = memoryStore()));
+}
+// ── Who saved it ──
+/** Who's saving: the user, through the UI, an API token, or an app acting for them. */
+function authorOf(auth) {
+    if (auth.oauth)
+        return { userId: auth.userId, username: auth.username, via: 'oauth', clientId: auth.oauth.clientId, clientName: auth.oauth.clientName };
+    if (auth.apiToken)
+        return { userId: auth.userId, username: auth.username, via: 'apiToken', tokenId: auth.apiToken.tokenId };
+    return { userId: auth.userId, username: auth.username, via: 'session' };
+}
+// ── The tree ──
+/** A document and everything inside it (a folder's documents, at any depth). */
+function withDescendants(documents, id) {
+    const ids = [id];
+    for (let i = 0; i < ids.length; i++) {
+        for (const d of documents)
+            if (d.parentId === ids[i])
+                ids.push(d.id);
+    }
+    return ids;
+}
+// ── Sections ──
+// A section is what's under a markdown heading ("## Architecture"), up to the next heading of
+// the same level or above. Headings inside a fenced code block aren't headings.
+const HEADING = /^(#{1,6})[ \t]+(.*?)[ \t]*#*[ \t]*$/;
+const FENCE = /^[ \t]*(```|~~~)/;
+const headingOf = (text) => {
+    const match = text.trim().match(/^(#{1,6})[ \t]+(.*?)[ \t]*#*$/);
+    return match ? { level: match[1].length, title: match[2].trim() } : { level: null, title: text.trim() };
+};
+/**
+ * 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.
+ */
+function replaceSection(markdown, heading, body) {
+    const wanted = headingOf(heading);
+    const lines = markdown.split('\n');
+    const headings = [];
+    let fenced = false;
+    lines.forEach((line, i) => {
+        if (FENCE.test(line))
+            fenced = !fenced;
+        const match = !fenced && line.match(HEADING);
+        if (match)
+            headings.push({ line: i, level: match[1].length, title: match[2].trim() });
+    });
+    const matches = headings.filter(h => h.title === wanted.title && (wanted.level === null || h.level === wanted.level));
+    if (!matches.length)
+        return { error: 'not-found' };
+    if (matches.length > 1)
+        return { error: 'ambiguous' };
+    const [target] = matches;
+    const next = headings.find(h => h.line > target.line && h.level <= target.level);
+    const end = next ? next.line : lines.length;
+    const text = body.replace(/^(\s*\n)+/, '').replace(/\s+$/, '');
+    const replaced = [
+        ...lines.slice(0, target.line + 1),
+        ...(text ? ['', ...text.split('\n')] : []),
+        ...(next ? [''] : []),
+        ...lines.slice(end),
+    ];
+    // A document's last line ends it, as it did.
+    if (!next && markdown.endsWith('\n'))
+        replaced.push('');
+    return { content: replaced.join('\n') };
+}
+/**
+ * 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.
+ */
+async function publishedDocuments(projectId, scope = {}) {
+    const store = documentStore();
+    const documents = await store.list(projectId);
+    const within = scope.folderId ? new Set(withDescendants(documents, scope.folderId)) : null;
+    const chosen = documents.filter(d => d.kind === 'document' && d.exportable && d.publishedVersion !== null
+        && (!within || within.has(d.id))
+        && (!scope.documentIds?.length || scope.documentIds.includes(d.id)));
+    const published = await Promise.all(chosen.map(async (d) => {
+        const version = await store.version(projectId, d.id, d.publishedVersion);
+        return version && {
+            id: d.id, title: version.title, parentId: d.parentId, position: d.position,
+            version: version.version, content: version.content, publishedAt: version.createdAt,
+        };
+    }));
+    return published.filter((d) => !!d);
+}

package/dist/services/executor.js

@@ -8,6 +8,7 @@ const connectionResolver_1 = require("./connectionResolver");
 const userIntegration_1 = require("./userIntegration");
 const oauthClient_1 = require("./oauthClient");
 const jobQueue_1 = require("./jobQueue");
+const documents_1 = require("./documents");
 const mediaProcessor_1 = require("./mediaProcessor");
 const vfxProcessor_1 = require("./vfxProcessor");
 const aiProcessor_1 = require("./aiProcessor");
@@ -143,6 +144,13 @@ async function executeExport(nodeSchema, project, config, { public: isPublic = t
                 await (0, connectionResolver_1.releaseDbClient)(resolved);
             }
         }
+        else if (node.type === 'documentsNode') {
+            // The project's own documents, as published: an edit is a draft, delivered only once a
+            // version of it is published. Its own data, so public exports read it too.
+            const documentIds = Array.isArray(node.data?.documentIds) ? node.data.documentIds : undefined;
+            const folderId = node.data?.folderId || undefined;
+            dataResults.push(await (0, documents_1.publishedDocuments)(project._id?.toString() ?? project.id, { folderId, documentIds }));
+        }
         else if (node.type === 'connectionNode') {
             const connection = project.connections?.find((c) => c.id === node.data?.connectionId);
             if (!connection)

package/dist/services/oauthTokens.js

@@ -16,12 +16,12 @@ const crypto_1 = __importDefault(require("crypto"));
 exports.OAUTH_SCOPES = ['streamby:read', 'streamby:write'];
 const READ_PERMISSIONS = [
     'project:read', 'members:read', 'assets:read', 'production:read', 'workflow:read',
-    'exports:read', 'rights:read', 'jobs:read',
+    'exports:read', 'rights:read', 'jobs:read', 'docs:read',
 ];
 // Making and changing, as the consent screen says: never deleting, nor managing members.
 const WRITE_PERMISSIONS = [
     'project:update', 'assets:write', 'production:write', 'workflow:write', 'exports:write',
-    'rights:write', 'jobs:run', 'projects:create',
+    'rights:write', 'jobs:run', 'projects:create', 'docs:write',
 ];
 /** The permissions each scope grants. */
 exports.OAUTH_SCOPE_PERMISSIONS = {

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

package/dist/services/projectIntegration.d.ts

@@ -13,4 +13,18 @@ type ClassifyResult = {
     status: number;
 };
 export declare function classifyIntegrationId(id: string, auth: Auth, config: StreamByConfig, projectId: string): Promise<ClassifyResult>;
+declare const LIST_OF: {
+    readonly database: "dbConnections";
+    readonly storage: "storageConnections";
+    readonly service: "integrationConnections";
+};
+/**
+ * Connects an integration to a project: a built-in (the host's database or storage) or one of
+ * the user's own. A built-in it was disconnected from comes back with the id it had, so what
+ * was kept for it (its files, its records) is its own again. With `kind`, only one of that kind.
+ */
+export declare function connectIntegration(project: any, integrationId: string, auth: Auth, config: StreamByConfig, options?: {
+    kind?: keyof typeof LIST_OF;
+    description?: string;
+}): Promise<ClassifyResult>;
 export {};

package/dist/services/projectIntegration.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.classifyIntegrationId = classifyIntegrationId;
+exports.connectIntegration = connectIntegration;
 const crypto_1 = __importDefault(require("crypto"));
 const manager_1 = require("../models/manager");
 const builtinAccess_1 = require("../utils/builtinAccess");
@@ -71,3 +72,34 @@ async function classifyIntegrationId(id, auth, config, projectId) {
         },
     };
 }
+const LIST_OF = { database: 'dbConnections', storage: 'storageConnections', service: 'integrationConnections' };
+const NOUN_OF = { database: 'a database', storage: 'a storage', service: 'a service' };
+/**
+ * Connects an integration to a project: a built-in (the host's database or storage) or one of
+ * the user's own. A built-in it was disconnected from comes back with the id it had, so what
+ * was kept for it (its files, its records) is its own again. With `kind`, only one of that kind.
+ */
+async function connectIntegration(project, integrationId, auth, config, options = {}) {
+    const projectId = String(project._id ?? project.id);
+    const alreadyConnected = [...(project.dbConnections ?? []), ...(project.storageConnections ?? []), ...(project.integrationConnections ?? [])]
+        .some((c) => c.integrationId === integrationId);
+    if (alreadyConnected)
+        return { error: 'This integration is already connected to the project', status: 400 };
+    const result = await classifyIntegrationId(integrationId, auth, config, projectId);
+    if ('error' in result)
+        return result;
+    if (options.kind && result.kind !== options.kind)
+        return { error: `This integration isn't ${NOUN_OF[options.kind]}`, status: 400 };
+    const before = (project.disconnectedBuiltins ?? []).find((d) => d.integrationId === integrationId);
+    const connection = {
+        ...result.connection,
+        ...(before && result.connection.source === 'builtin' ? { id: before.connectionId } : {}),
+        ...(options.description ? { description: options.description } : {}),
+    };
+    const Project = (0, manager_1.getModel)('projects');
+    await Project.update({ _id: projectId }, { $push: { [LIST_OF[result.kind]]: connection } });
+    // By integrationId alone: a SQL project's $pull matches one key.
+    if (before)
+        await Project.update({ _id: projectId }, { $pull: { disconnectedBuiltins: { integrationId } } });
+    return { kind: result.kind, connection };
+}

package/dist/services/rights.d.ts

@@ -0,0 +1,44 @@
+export declare const LICENSE_TYPES: readonly ["CC BY", "CC BY-SA", "CC BY-ND", "CC BY-NC", "CC BY-NC-SA", "CC BY-NC-ND", "CC0", "Free Standard", "Standard", "Editorial"];
+export type LicenseType = typeof LICENSE_TYPES[number];
+export declare const RIGHTS_FIELDS: readonly ["sourceUrl", "creatorName", "creatorUrl", "licenseType", "comments"];
+type RightsField = typeof RIGHTS_FIELDS[number];
+export interface AssetRights {
+    assetId: string;
+    projectId: string;
+    sourceUrl: string | null;
+    creatorName: string | null;
+    creatorUrl: string | null;
+    licenseType: LicenseType | null;
+    comments: string | null;
+    updatedBy?: string;
+    updatedAt?: Date;
+}
+export type RightsValues = Partial<Pick<AssetRights, RightsField>>;
+/**
+ * The fields given of an asset's license metadata, checked: text (a link, an http(s) URL) and a
+ * license from the list. A field given empty or null is cleared.
+ */
+export declare function checkRights(body: any): {
+    values: RightsValues;
+} | {
+    error: string;
+};
+/** The license metadata given as query params (an upload's), checked; null if none given. */
+export declare function rightsFromQuery(query: Record<string, unknown>): {
+    values: RightsValues;
+} | {
+    error: string;
+} | null;
+export declare function getRights(projectId: string, assetId: string): Promise<AssetRights | null>;
+/** Several assets' license metadata, by asset id (those with none are missing). */
+export declare function getRightsOf(projectId: string, assetIds: string[]): Promise<Map<string, AssetRights>>;
+export declare function broadcastRights(project: any, data: {
+    action: 'saved' | 'deleted';
+    assetIds: string[];
+    rights?: AssetRights;
+}): void;
+/** Sets the fields given of an asset's license metadata (checked already), and tells the project. */
+export declare function saveRights(project: any, assetId: string, values: RightsValues, userId: string): Promise<AssetRights>;
+/** An asset's license metadata, gone with it (or, without an asset, a whole project's). */
+export declare function deleteRightsOf(projectId: string, assetId?: string): Promise<void>;
+export {};

package/dist/services/rights.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RIGHTS_FIELDS = exports.LICENSE_TYPES = void 0;
+exports.checkRights = checkRights;
+exports.rightsFromQuery = rightsFromQuery;
+exports.getRights = getRights;
+exports.getRightsOf = getRightsOf;
+exports.broadcastRights = broadcastRights;
+exports.saveRights = saveRights;
+exports.deleteRightsOf = deleteRightsOf;
+const nosqlDb_1 = require("../utils/nosqlDb");
+const auth_1 = require("../utils/auth");
+const wsHub_1 = require("./wsHub");
+// An asset's license metadata: where it was taken from, who made it, and under what license.
+// Kept in the `asset_rights` collection, one record per asset (for all its versions), the
+// only place it lives: a credits sheet reads it from here, and writes to here.
+exports.LICENSE_TYPES = [
+    'CC BY', 'CC BY-SA', 'CC BY-ND', 'CC BY-NC', 'CC BY-NC-SA', 'CC BY-NC-ND', 'CC0', 'Free Standard', 'Standard', 'Editorial',
+];
+exports.RIGHTS_FIELDS = ['sourceUrl', 'creatorName', 'creatorUrl', 'licenseType', 'comments'];
+const URL_FIELDS = ['sourceUrl', 'creatorUrl'];
+const MAX_TEXT = 2000;
+const isLicense = (value) => exports.LICENSE_TYPES.includes(value);
+const isUrl = (value) => {
+    try {
+        return ['http:', 'https:'].includes(new URL(value).protocol);
+    }
+    catch {
+        return false;
+    }
+};
+/**
+ * The fields given of an asset's license metadata, checked: text (a link, an http(s) URL) and a
+ * license from the list. A field given empty or null is cleared.
+ */
+function checkRights(body) {
+    const values = {};
+    for (const field of exports.RIGHTS_FIELDS) {
+        const raw = body?.[field];
+        if (raw === undefined)
+            continue;
+        if (raw !== null && typeof raw !== 'string')
+            return { error: `${field} must be text` };
+        const value = typeof raw === 'string' ? raw.trim() : '';
+        if (!value) {
+            values[field] = null;
+            continue;
+        }
+        if (value.length > MAX_TEXT)
+            return { error: `${field} has at most ${MAX_TEXT} characters` };
+        if (field === 'licenseType') {
+            if (!isLicense(value))
+                return { error: `licenseType is one of: ${exports.LICENSE_TYPES.join(', ')}` };
+            values.licenseType = value;
+        }
+        else if (URL_FIELDS.includes(field) && !isUrl(value)) {
+            return { error: `${field} must be an http(s) URL` };
+        }
+        else {
+            values[field] = value;
+        }
+    }
+    return { values };
+}
+/** The license metadata given as query params (an upload's), checked; null if none given. */
+function rightsFromQuery(query) {
+    const given = Object.fromEntries(exports.RIGHTS_FIELDS.filter(f => typeof query[f] === 'string').map(f => [f, query[f]]));
+    return Object.keys(given).length ? checkRights(given) : null;
+}
+const collection = () => (0, nosqlDb_1.nosqlDb)()?.collection('asset_rights') ?? null;
+// A record as it's answered: only the fields it has now (a license off the list reads as none).
+const readRights = (record) => record && {
+    assetId: record.assetId,
+    projectId: record.projectId,
+    sourceUrl: record.sourceUrl ?? null,
+    creatorName: record.creatorName ?? null,
+    creatorUrl: record.creatorUrl ?? null,
+    licenseType: isLicense(record.licenseType) ? record.licenseType : null,
+    comments: record.comments ?? null,
+    ...(record.updatedBy ? { updatedBy: record.updatedBy } : {}),
+    ...(record.updatedAt ? { updatedAt: record.updatedAt } : {}),
+};
+async function getRights(projectId, assetId) {
+    const col = collection();
+    return col ? readRights(await col.findOne({ projectId, assetId })) : null;
+}
+/** Several assets' license metadata, by asset id (those with none are missing). */
+async function getRightsOf(projectId, assetIds) {
+    const col = collection();
+    if (!col || !assetIds.length)
+        return new Map();
+    const records = await col.find({ projectId, assetId: { $in: assetIds } }).toArray();
+    return new Map(records.map(r => [r.assetId, readRights(r)]));
+}
+// What changed in a project's assets' license metadata, to whoever is in it now: the credits
+// sheets they have open read their rows again.
+function broadcastRights(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: 'assetRightsEvent', data: { projectId, ...data } });
+    }
+}
+/** Sets the fields given of an asset's license metadata (checked already), and tells the project. */
+async function saveRights(project, assetId, values, userId) {
+    const col = collection();
+    if (!col)
+        throw new Error('Database not available');
+    const projectId = String(project._id ?? project.id);
+    // The fields an earlier record had that this one doesn't (holder, territory...) go.
+    const $unset = { rightsHolder: '', licenseUrl: '', territory: '', expiresAt: '', usageRestrictions: '', notes: '' };
+    await col.updateOne({ projectId, assetId }, { $set: { assetId, projectId, ...values, updatedBy: userId, updatedAt: new Date() }, $unset }, { upsert: true });
+    const rights = (await getRights(projectId, assetId));
+    broadcastRights(project, { action: 'saved', assetIds: [assetId], rights });
+    return rights;
+}
+/** An asset's license metadata, gone with it (or, without an asset, a whole project's). */
+async function deleteRightsOf(projectId, assetId) {
+    const col = collection();
+    if (!col || !projectId)
+        return;
+    await col.deleteMany(assetId ? { projectId, assetId } : { projectId });
+}