streamby-core 0.37.0 → 0.39.0

package/dist/services/apiConnection.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addApiConnection = addApiConnection;
+exports.updateApiConnection = updateApiConnection;
+exports.deleteApiConnection = deleteApiConnection;
+const mongodb_1 = require("mongodb");
+const manager_1 = require("../models/manager");
+async function addApiConnection(config, projectId, data) {
+    const ProjectModel = (0, manager_1.getModel)('projects');
+    const project = await ProjectModel.findOne({ _id: projectId });
+    if (!project) {
+        throw new Error('Project not found.');
+    }
+    const connection = {
+        id: new mongodb_1.ObjectId().toHexString(),
+        name: data.name,
+        prefix: data.prefix,
+        apiUrl: data.apiUrl,
+        method: data.method,
+        projectId,
+        createdAt: new Date(),
+        ...(data.description !== undefined && { description: data.description }),
+        ...(data.credentialId !== undefined && { credentialId: data.credentialId }),
+    };
+    const updatedProject = await ProjectModel.update({ _id: projectId }, { $push: { apiConnections: connection } });
+    if (!updatedProject) {
+        throw new Error('Failed to add API connection to project.');
+    }
+    return connection;
+}
+async function updateApiConnection(config, projectId, connectionId, data) {
+    const ProjectModel = (0, manager_1.getModel)('projects');
+    const project = await ProjectModel.findOne({ _id: projectId });
+    if (!project)
+        throw new Error('Project not found.');
+    const connections = project.apiConnections ?? [];
+    const index = connections.findIndex((c) => c.id === connectionId);
+    if (index === -1)
+        throw new Error('API connection not found.');
+    const updated = {
+        ...connections[index],
+        ...(data.name !== undefined && { name: data.name }),
+        ...(data.apiUrl !== undefined && { apiUrl: data.apiUrl }),
+        ...(data.method !== undefined && { method: data.method }),
+        ...(data.prefix !== undefined && { prefix: data.prefix }),
+        ...(data.description !== undefined && { description: data.description }),
+        ...(data.credentialId !== undefined && { credentialId: data.credentialId }),
+    };
+    connections[index] = updated;
+    const result = await ProjectModel.update({ _id: projectId }, { $set: { apiConnections: connections } });
+    if (!result)
+        throw new Error('Failed to update API connection.');
+    return updated;
+}
+async function deleteApiConnection(config, projectId, connectionId) {
+    const ProjectModel = (0, manager_1.getModel)('projects');
+    const project = await ProjectModel.findOne({ _id: projectId });
+    if (!project) {
+        throw new Error('Project not found.');
+    }
+    const updatedProject = await ProjectModel.update({ _id: projectId }, { $pull: { apiConnections: { id: connectionId } } });
+    if (!updatedProject) {
+        throw new Error('Failed to delete API connection from project.');
+    }
+}

package/dist/services/apiTokenPermissions.js

@@ -39,7 +39,7 @@ const RULES = [
     rule('read', '^/users/search', 'members:manage'),
     rule('read', '^/jobs/[^/]+', 'jobs:read'),
     // The project itself and its settings.
-    rule('read', `${P}(/preview)?`, 'project:read'),
+    rule('read', `${P}(/preview|/origins|/integrations)?`, 'project:read'),
     rule(['PATCH'], P, 'project:update'),
     rule('delete', P, 'project:delete'),
     rule(['PATCH'], `${P}/(archive|unarchive)`, 'project:update', { userTokenOnly: true }),
@@ -62,11 +62,15 @@ const RULES = [
     rule('read', `${P}/connections/storage/[^/]+/(files|folders)(/.+)?`, 'assets:read'),
     rule(['POST', 'PATCH'], `${P}/connections/storage/[^/]+/(files|folders)(/.+)?`, 'assets:write'),
     rule('delete', `${P}/connections/storage/[^/]+/(files|folders)/[^/]+`, 'assets:delete'),
-    rule('read', `${P}/assets/[^/]+/(metadata|versions|qc-report|dependency-graph)`, 'assets:read'),
+    rule('read', `${P}/assets/[^/]+/(metadata|versions|qc-report|dependency-graph|download-url)`, 'assets:read'),
     rule(['PATCH'], `${P}/assets/[^/]+/metadata`, 'assets:write'),
     rule(['POST'], `${P}/assets/[^/]+/qc-report`, 'assets:write'),
     rule('read', `${P}/(reviews(/[^/]+)?|assets/[^/]+/versions/[^/]+/annotations)`, 'assets:read'),
     rule(['POST', 'PATCH'], `${P}/(reviews(/[^/]+/decision)?|assets/[^/]+/versions/[^/]+/annotations(/[^/]+/resolve)?)`, 'assets:write'),
+    // Deliverables: an asset (or a version) delivered for a shot or an export.
+    rule('read', `${P}/deliverables`, 'assets:read'),
+    rule(['POST'], `${P}/deliverables`, 'assets:write'),
+    rule('delete', `${P}/deliverables/[^/]+`, 'assets:write'),
     // Rights.
     rule('read', `${P}/assets/[^/]+/rights`, 'rights:read'),
     rule(['PUT'], `${P}/assets/[^/]+/rights`, 'rights:write'),
@@ -84,7 +88,7 @@ const RULES = [
     rule(['POST'], `${P}/pipelines`, 'workflow:write'),
     rule(['PATCH', 'DELETE'], `${P}/pipelines/[^/]+`, 'workflow:write'),
     // Exports.
-    rule('read', `${P}/exports/[^/]+`, 'exports:read'),
+    rule('read', `${P}/exports(/[^/]+)?`, 'exports:read'),
     rule(['POST'], `${P}/exports`, 'exports:write'),
     rule(['PATCH', 'DELETE'], `${P}/exports/[^/]+`, 'exports:write'),
     // Jobs: transcoding, rendering, AI, publishing a deliverable.

package/dist/services/assetVersions.d.ts

@@ -0,0 +1,48 @@
+export interface AssetVersion {
+    versionId: string;
+    assetId: string;
+    projectId: string;
+    version: number;
+    storageKey: string;
+    contentType: string | null;
+    fileName: string | null;
+    createdBy: string | null;
+    createdAt: Date;
+}
+export declare const versionsCollection: () => import("mongodb").Collection<import("bson").Document> | null;
+/** The key an asset's version `n` is archived in, next to the asset's own key. */
+export declare const archivedVersionKey: (assetKey: string, version: number) => string;
+/** Records the first version of an asset just made (or one made before versions were kept). */
+export declare function recordFirstVersion(file: {
+    fileId: string;
+    projectId: string;
+    storageKey: string;
+    contentType?: string;
+    displayName?: string;
+    uploadedBy?: string;
+    createdAt?: Date;
+}): Promise<void>;
+/**
+ * Makes room for a new version of an asset, to be uploaded to its own key: its current version
+ * is copied to an archive key first (`copyFile`) and recorded there. If the copy fails nothing
+ * changes, and it throws: the current version is never lost.
+ */
+export declare function archiveCurrentVersion(file: {
+    fileId: string;
+    projectId: string;
+    storageKey: string;
+    contentType?: string;
+    displayName?: string;
+    uploadedBy?: string;
+    createdAt?: Date;
+}, upload: {
+    fileName: string;
+    contentType: string;
+    userId: string;
+}, copyFile: (from: string, to: string) => Promise<void>): Promise<AssetVersion>;
+/** One of an asset's versions, or null. */
+export declare function findVersion(projectId: string, assetId: string, versionId: string): Promise<AssetVersion | null>;
+/** Every key an asset's versions are stored in (its current one included). */
+export declare function versionStorageKeys(projectId: string, assetId: string, currentKey?: string): Promise<string[]>;
+/** Forgets an asset's versions (once their files are deleted). */
+export declare function deleteVersions(projectId: string, assetId: string): Promise<void>;

package/dist/services/assetVersions.js

@@ -0,0 +1,84 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.archivedVersionKey = exports.versionsCollection = void 0;
+exports.recordFirstVersion = recordFirstVersion;
+exports.archiveCurrentVersion = archiveCurrentVersion;
+exports.findVersion = findVersion;
+exports.versionStorageKeys = versionStorageKeys;
+exports.deleteVersions = deleteVersions;
+const crypto_1 = __importDefault(require("crypto"));
+const mongodb_1 = require("mongodb");
+const nosqlDb_1 = require("../utils/nosqlDb");
+const versionsCollection = () => (0, nosqlDb_1.nosqlDb)()?.collection('asset_versions') ?? null;
+exports.versionsCollection = versionsCollection;
+/** The key an asset's version `n` is archived in, next to the asset's own key. */
+const archivedVersionKey = (assetKey, version) => {
+    const extension = /(\.[^./]*)$/.exec(assetKey)?.[1] ?? '';
+    return `${assetKey.slice(0, assetKey.length - extension.length)}.v${version}${extension}`;
+};
+exports.archivedVersionKey = archivedVersionKey;
+/** Records the first version of an asset just made (or one made before versions were kept). */
+async function recordFirstVersion(file) {
+    const col = (0, exports.versionsCollection)();
+    if (!col)
+        return;
+    if (await col.findOne({ assetId: file.fileId, projectId: file.projectId }))
+        return;
+    await col.insertOne({
+        _id: new mongodb_1.ObjectId(),
+        versionId: crypto_1.default.randomUUID(),
+        assetId: file.fileId,
+        projectId: file.projectId,
+        version: 1,
+        storageKey: file.storageKey,
+        contentType: file.contentType ?? null,
+        fileName: file.displayName ?? null,
+        createdBy: file.uploadedBy ?? null,
+        createdAt: file.createdAt ?? new Date(),
+    });
+}
+/**
+ * Makes room for a new version of an asset, to be uploaded to its own key: its current version
+ * is copied to an archive key first (`copyFile`) and recorded there. If the copy fails nothing
+ * changes, and it throws: the current version is never lost.
+ */
+async function archiveCurrentVersion(file, upload, copyFile) {
+    const col = (0, exports.versionsCollection)();
+    if (!col)
+        throw new Error('Database not available');
+    await recordFirstVersion(file);
+    const [current] = await col.find({ assetId: file.fileId, projectId: file.projectId }).sort({ version: -1 }).limit(1).toArray();
+    const currentVersion = current?.version ?? 1;
+    const archiveKey = (0, exports.archivedVersionKey)(file.storageKey, currentVersion);
+    await copyFile(file.storageKey, archiveKey);
+    await col.updateOne({ assetId: file.fileId, projectId: file.projectId, version: currentVersion }, { $set: { storageKey: archiveKey } });
+    const record = {
+        versionId: crypto_1.default.randomUUID(),
+        assetId: file.fileId,
+        projectId: file.projectId,
+        version: currentVersion + 1,
+        storageKey: file.storageKey,
+        contentType: upload.contentType,
+        fileName: upload.fileName,
+        createdBy: upload.userId,
+        createdAt: new Date(),
+    };
+    await col.insertOne({ _id: new mongodb_1.ObjectId(), ...record });
+    return record;
+}
+/** One of an asset's versions, or null. */
+async function findVersion(projectId, assetId, versionId) {
+    return (await (0, exports.versionsCollection)()?.findOne({ projectId, assetId, versionId })) ?? null;
+}
+/** Every key an asset's versions are stored in (its current one included). */
+async function versionStorageKeys(projectId, assetId, currentKey) {
+    const versions = ((await (0, exports.versionsCollection)()?.find({ projectId, assetId }).toArray()) ?? []);
+    return [...new Set([...(currentKey ? [currentKey] : []), ...versions.map(v => v.storageKey)])];
+}
+/** Forgets an asset's versions (once their files are deleted). */
+async function deleteVersions(projectId, assetId) {
+    await (0, exports.versionsCollection)()?.deleteMany({ projectId, assetId });
+}

package/dist/services/credential.d.ts

@@ -0,0 +1,8 @@
+import { StreamByConfig, Credential, ProjectInfo } from '../types';
+export declare function addCredential(config: StreamByConfig, projectId: string, newCredential: Omit<Credential, 'encryptedValue'> & {
+    value: string;
+}): Promise<ProjectInfo>;
+export declare function updateCredential(config: StreamByConfig, projectId: string, credentialId: string, updates: Partial<Omit<Credential, 'encryptedValue'> & {
+    value: string;
+}>): Promise<ProjectInfo>;
+export declare function deleteCredential(config: StreamByConfig, projectId: string, credentialId: string): Promise<ProjectInfo>;

package/dist/services/credential.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addCredential = addCredential;
+exports.updateCredential = updateCredential;
+exports.deleteCredential = deleteCredential;
+const manager_1 = require("../models/manager");
+const encryption_1 = require("../utils/encryption");
+const mongodb_1 = require("mongodb");
+async function addCredential(config, projectId, newCredential) {
+    if (!(0, encryption_1.isEncryptionKeySet)()) {
+        throw new Error('Encryption key is not set. Cannot add credentials.');
+    }
+    const ProjectModel = (0, manager_1.getModel)('projects');
+    const project = await ProjectModel.findOne({ _id: projectId });
+    if (!project) {
+        throw new Error('Project not found.');
+    }
+    const encryptedValue = (0, encryption_1.encrypt)(newCredential.value);
+    const credentialToSave = {
+        id: newCredential.id || new mongodb_1.ObjectId().toHexString(), // Generate ID if not provided
+        key: newCredential.key,
+        encryptedValue: encryptedValue,
+    };
+    const updatedProject = await ProjectModel.update({ _id: projectId }, { $push: { credentials: credentialToSave } });
+    if (!updatedProject) {
+        throw new Error('Failed to add credential to project.');
+    }
+    return updatedProject;
+}
+async function updateCredential(config, projectId, credentialId, updates) {
+    if (!(0, encryption_1.isEncryptionKeySet)()) {
+        throw new Error('Encryption key is not set. Cannot update credentials.');
+    }
+    const ProjectModel = (0, manager_1.getModel)('projects');
+    const project = await ProjectModel.findOne({ _id: projectId });
+    if (!project) {
+        throw new Error('Project not found.');
+    }
+    const credentialIndex = project.credentials?.findIndex(cred => cred.id === credentialId);
+    if (credentialIndex === undefined || credentialIndex === -1) {
+        throw new Error(`Credential with ID ${credentialId} not found.`);
+    }
+    const currentCredential = project.credentials[credentialIndex];
+    let encryptedValue = currentCredential.encryptedValue;
+    if (updates.value !== undefined) {
+        encryptedValue = (0, encryption_1.encrypt)(updates.value);
+    }
+    const updatedCredential = {
+        ...currentCredential,
+        key: updates.key || currentCredential.key,
+        encryptedValue: encryptedValue,
+    };
+    const updatedProject = await ProjectModel.update({ _id: projectId, 'credentials.id': credentialId }, { $set: { 'credentials.$': updatedCredential } });
+    if (!updatedProject) {
+        throw new Error('Failed to update credential in project.');
+    }
+    return updatedProject;
+}
+async function deleteCredential(config, projectId, credentialId) {
+    const ProjectModel = (0, manager_1.getModel)('projects');
+    const project = await ProjectModel.findOne({ _id: projectId });
+    if (!project) {
+        throw new Error('Project not found.');
+    }
+    const updatedProject = await ProjectModel.update({ _id: projectId }, { $pull: { credentials: { id: credentialId } } });
+    if (!updatedProject) {
+        throw new Error('Failed to delete credential from project.');
+    }
+    return updatedProject;
+}

package/dist/services/deliverables.d.ts

@@ -0,0 +1,26 @@
+export interface Deliverable {
+    id: string;
+    projectId: string;
+    assetId: string;
+    versionId: string | null;
+    shotId: string | null;
+    exportId: string | null;
+    note: string | null;
+    createdBy: string;
+    createdAt: Date;
+}
+export declare const deliverablesCollection: () => import("mongodb").Collection<import("bson").Document> | null;
+export declare function createDeliverable(fields: Omit<Deliverable, 'id' | 'createdAt'>): Promise<Deliverable>;
+/** A project's deliverables, of one shot or export if given, newest first. */
+export declare function listDeliverables(projectId: string, of?: {
+    shotId?: string;
+    exportId?: string;
+}): Promise<Deliverable[]>;
+/** Removes a deliverable (never its asset). Whether there was one. */
+export declare function deleteDeliverable(projectId: string, id: string): Promise<boolean>;
+/** Forgets the deliverables of what's gone: an asset, shots, or an export. */
+export declare function deleteDeliverablesOf(projectId: string, of: {
+    assetId?: string;
+    shotIds?: string[];
+    exportId?: string;
+}): Promise<void>;

package/dist/services/deliverables.js

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deliverablesCollection = void 0;
+exports.createDeliverable = createDeliverable;
+exports.listDeliverables = listDeliverables;
+exports.deleteDeliverable = deleteDeliverable;
+exports.deleteDeliverablesOf = deleteDeliverablesOf;
+const crypto_1 = __importDefault(require("crypto"));
+const mongodb_1 = require("mongodb");
+const nosqlDb_1 = require("../utils/nosqlDb");
+const deliverablesCollection = () => (0, nosqlDb_1.nosqlDb)()?.collection('deliverables') ?? null;
+exports.deliverablesCollection = deliverablesCollection;
+const strip = ({ _id, ...deliverable }) => deliverable;
+async function createDeliverable(fields) {
+    const col = (0, exports.deliverablesCollection)();
+    if (!col)
+        throw new Error('Database not available');
+    const deliverable = { id: crypto_1.default.randomUUID(), ...fields, createdAt: new Date() };
+    await col.insertOne({ _id: new mongodb_1.ObjectId(), ...deliverable });
+    return deliverable;
+}
+/** A project's deliverables, of one shot or export if given, newest first. */
+async function listDeliverables(projectId, of = {}) {
+    const col = (0, exports.deliverablesCollection)();
+    if (!col)
+        throw new Error('Database not available');
+    const filter = { projectId };
+    if (of.shotId)
+        filter.shotId = of.shotId;
+    if (of.exportId)
+        filter.exportId = of.exportId;
+    return (await col.find(filter).sort({ createdAt: -1 }).toArray()).map(strip);
+}
+/** Removes a deliverable (never its asset). Whether there was one. */
+async function deleteDeliverable(projectId, id) {
+    const col = (0, exports.deliverablesCollection)();
+    if (!col)
+        throw new Error('Database not available');
+    return (await col.deleteOne({ projectId, id })).deletedCount > 0;
+}
+/** Forgets the deliverables of what's gone: an asset, shots, or an export. */
+async function deleteDeliverablesOf(projectId, of) {
+    const col = (0, exports.deliverablesCollection)();
+    if (!col)
+        return;
+    if (of.assetId)
+        await col.deleteMany({ projectId, assetId: of.assetId });
+    if (of.shotIds?.length)
+        await col.deleteMany({ projectId, shotId: { $in: of.shotIds } });
+    if (of.exportId)
+        await col.deleteMany({ projectId, exportId: of.exportId });
+}

package/dist/services/mediaProcessor.js

@@ -69,7 +69,9 @@ async function runIngestJob(jobId, fileId, projectId) {
         }
         (0, jobQueue_1.updateJob)(jobId, { stage: 'creating-version', progress: 70 });
         const versionsCol = getVersionsCollection();
-        if (versionsCol) {
+        // Its upload already recorded the version it's in; only an asset from before versions
+        // were kept gets one here.
+        if (versionsCol && !(await versionsCol.findOne({ assetId: fileId, projectId, storageKey: fileDoc.storageKey }))) {
             const existing = await versionsCol.countDocuments({ assetId: fileId, projectId });
             await versionsCol.insertOne({
                 _id: new mongodb_1.ObjectId(),

package/dist/services/pipeline.d.ts

@@ -0,0 +1,2 @@
+import { NodeSchema, StreamByConfig } from '../types';
+export declare function executePipeline(nodeSchema: NodeSchema, project: any, config: StreamByConfig): Promise<any>;