streamby-core 0.28.5 → 0.29.0

package/dist/middleware/routes/media.js

@@ -0,0 +1,189 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mediaRouter = mediaRouter;
+const express_1 = require("express");
+const manager_1 = require("../../models/manager");
+const auth_1 = require("../../utils/auth");
+const jobQueue_1 = require("../../services/jobQueue");
+const mediaProcessor_1 = require("../../services/mediaProcessor");
+const storage_1 = require("../../providers/storage");
+const connectionManager_1 = require("../../adapters/database/connectionManager");
+function getMetadataCollection() {
+    const ids = (0, connectionManager_1.getConnectedIds)().filter(id => (0, connectionManager_1.getConnection)(id).type === 'nosql');
+    if (!ids.length)
+        return null;
+    return (0, connectionManager_1.getConnection)(ids[0]).client.db().collection('media_metadata');
+}
+function getVersionsCollection() {
+    const ids = (0, connectionManager_1.getConnectedIds)().filter(id => (0, connectionManager_1.getConnection)(id).type === 'nosql');
+    if (!ids.length)
+        return null;
+    return (0, connectionManager_1.getConnection)(ids[0]).client.db().collection('asset_versions');
+}
+function mediaRouter(config) {
+    const router = (0, express_1.Router)();
+    const adapter = config.adapter || (0, storage_1.createStorageProvider)(config.storageProviders);
+    const Project = (0, manager_1.getModel)('projects');
+    // GET /jobs/:jobId — poll job status
+    router.get('/jobs/:jobId', (req, res) => {
+        const job = (0, jobQueue_1.getJob)(req.params.jobId);
+        if (!job)
+            return res.status(404).json({ message: 'Job not found' });
+        res.json({ job });
+    });
+    // POST /projects/:projectId/jobs/ingest — queue an ingest job for an already-uploaded file
+    router.post('/projects/:projectId/jobs/ingest', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId } = req.params;
+            const { fileId } = req.body;
+            if (!fileId)
+                return res.status(400).json({ message: 'fileId is required' });
+            const project = await Project.findOne({ _id: projectId });
+            if (!project)
+                return res.status(404).json({ message: 'Project not found' });
+            if (!(0, auth_1.isProjectMember)(project, auth.userId))
+                return res.status(403).json({ message: 'Unauthorized' });
+            const job = (0, jobQueue_1.createJob)('ingest', auth.userId, projectId, { fileId });
+            // Run async — response returns immediately with jobId
+            setImmediate(() => (0, mediaProcessor_1.runIngestJob)(job.jobId, fileId, projectId));
+            res.status(202).json({ jobId: job.jobId, status: job.status });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    // POST /projects/:projectId/jobs/transcode
+    router.post('/projects/:projectId/jobs/transcode', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId } = req.params;
+            const { fileId, codec, resolution, outputFormat, bitrate, audioCodec } = req.body;
+            if (!fileId)
+                return res.status(400).json({ message: 'fileId is required' });
+            const project = await Project.findOne({ _id: projectId });
+            if (!project)
+                return res.status(404).json({ message: 'Project not found' });
+            if (!(0, auth_1.isProjectMember)(project, auth.userId))
+                return res.status(403).json({ message: 'Unauthorized' });
+            const job = (0, jobQueue_1.createJob)('transcode', auth.userId, projectId, {
+                fileId, codec, resolution, outputFormat, bitrate, audioCodec,
+            });
+            setImmediate(() => (0, mediaProcessor_1.runTranscodeJob)(job.jobId, fileId, projectId, { codec, resolution, outputFormat, bitrate, audioCodec }, adapter));
+            res.status(202).json({ jobId: job.jobId, status: job.status });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    // POST /projects/:projectId/jobs/thumbnail
+    router.post('/projects/:projectId/jobs/thumbnail', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId } = req.params;
+            const { fileId, timecode, resolution, strategy } = req.body;
+            if (!fileId)
+                return res.status(400).json({ message: 'fileId is required' });
+            const project = await Project.findOne({ _id: projectId });
+            if (!project)
+                return res.status(404).json({ message: 'Project not found' });
+            if (!(0, auth_1.isProjectMember)(project, auth.userId))
+                return res.status(403).json({ message: 'Unauthorized' });
+            const job = (0, jobQueue_1.createJob)('thumbnail', auth.userId, projectId, { fileId, timecode, resolution, strategy });
+            setImmediate(() => (0, mediaProcessor_1.runThumbnailJob)(job.jobId, fileId, projectId, { timecode, resolution, strategy }));
+            res.status(202).json({ jobId: job.jobId, status: job.status });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    // POST /projects/:projectId/jobs/caption
+    router.post('/projects/:projectId/jobs/caption', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId } = req.params;
+            const { fileId, sourceLanguage, outputFormat, provider } = req.body;
+            if (!fileId)
+                return res.status(400).json({ message: 'fileId is required' });
+            const project = await Project.findOne({ _id: projectId });
+            if (!project)
+                return res.status(404).json({ message: 'Project not found' });
+            if (!(0, auth_1.isProjectMember)(project, auth.userId))
+                return res.status(403).json({ message: 'Unauthorized' });
+            const job = (0, jobQueue_1.createJob)('caption', auth.userId, projectId, { fileId, sourceLanguage, outputFormat, provider });
+            setImmediate(() => (0, mediaProcessor_1.runCaptionJob)(job.jobId, fileId, projectId, { sourceLanguage, outputFormat, provider }));
+            res.status(202).json({ jobId: job.jobId, status: job.status });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    // GET /projects/:projectId/assets/:fileId/metadata
+    router.get('/projects/:projectId/assets/:fileId/metadata', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId, fileId } = req.params;
+            const project = await Project.findOne({ _id: projectId });
+            if (!project)
+                return res.status(404).json({ message: 'Project not found' });
+            if (!(0, auth_1.isProjectMember)(project, auth.userId))
+                return res.status(403).json({ message: 'Unauthorized' });
+            const col = getMetadataCollection();
+            if (!col)
+                return res.status(500).json({ message: 'Database not available' });
+            const meta = await col.findOne({ assetId: fileId, projectId });
+            res.json({ metadata: meta ?? null });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    // PATCH /projects/:projectId/assets/:fileId/metadata — update custom tags
+    router.patch('/projects/:projectId/assets/:fileId/metadata', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId, fileId } = req.params;
+            const { customTags } = req.body;
+            if (!customTags || typeof customTags !== 'object') {
+                return res.status(400).json({ message: 'customTags object is required' });
+            }
+            const project = await Project.findOne({ _id: projectId });
+            if (!project)
+                return res.status(404).json({ message: 'Project not found' });
+            if (!(0, auth_1.isProjectMember)(project, auth.userId))
+                return res.status(403).json({ message: 'Unauthorized' });
+            const col = getMetadataCollection();
+            if (!col)
+                return res.status(500).json({ message: 'Database not available' });
+            await col.updateOne({ assetId: fileId, projectId }, { $set: { customTags, updatedAt: new Date() } }, { upsert: true });
+            res.json({ message: 'Metadata updated' });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    // GET /projects/:projectId/assets/:fileId/versions
+    router.get('/projects/:projectId/assets/:fileId/versions', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId, fileId } = req.params;
+            const project = await Project.findOne({ _id: projectId });
+            if (!project)
+                return res.status(404).json({ message: 'Project not found' });
+            if (!(0, auth_1.isProjectMember)(project, auth.userId))
+                return res.status(403).json({ message: 'Unauthorized' });
+            const col = getVersionsCollection();
+            if (!col)
+                return res.status(500).json({ message: 'Database not available' });
+            const versions = await col
+                .find({ assetId: fileId, projectId })
+                .sort({ version: -1 })
+                .toArray();
+            res.json({ versions });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    return router;
+}

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

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

package/dist/middleware/routes/production.js

@@ -0,0 +1,362 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.productionRouter = productionRouter;
+const express_1 = require("express");
+const auth_1 = require("../../utils/auth");
+const connectionManager_1 = require("../../adapters/database/connectionManager");
+const manager_1 = require("../../models/manager");
+const crypto_1 = __importDefault(require("crypto"));
+function getDb() {
+    const ids = (0, connectionManager_1.getConnectedIds)().filter(id => (0, connectionManager_1.getConnection)(id).type === 'nosql');
+    if (!ids.length)
+        return null;
+    return (0, connectionManager_1.getConnection)(ids[0]).client.db();
+}
+function productionRouter(_config) {
+    const router = (0, express_1.Router)();
+    const Project = (0, manager_1.getModel)('projects');
+    // ── Sequences ──────────────────────────────────────────────────────────────
+    router.get('/projects/:projectId/production/sequences', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId } = req.params;
+            const project = await Project.findOne({ _id: projectId });
+            if (!project)
+                return res.status(404).json({ message: 'Project not found' });
+            if (!(0, auth_1.isProjectMember)(project, auth.userId))
+                return res.status(403).json({ message: 'Unauthorized' });
+            const db = getDb();
+            if (!db)
+                return res.status(500).json({ message: 'Database not available' });
+            const sequences = await db.collection('production_sequences')
+                .find({ projectId })
+                .sort({ order: 1, createdAt: 1 })
+                .toArray();
+            res.json({ sequences });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    router.post('/projects/:projectId/production/sequences', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId } = req.params;
+            const { name, description, order } = req.body;
+            if (!name)
+                return res.status(400).json({ message: 'name is required' });
+            const project = await Project.findOne({ _id: projectId });
+            if (!project)
+                return res.status(404).json({ message: 'Project not found' });
+            if (!(0, auth_1.isProjectMember)(project, auth.userId))
+                return res.status(403).json({ message: 'Unauthorized' });
+            const db = getDb();
+            if (!db)
+                return res.status(500).json({ message: 'Database not available' });
+            const now = new Date();
+            const sequence = {
+                id: crypto_1.default.randomUUID(),
+                projectId,
+                name,
+                description: description ?? null,
+                order: order ?? 0,
+                createdBy: auth.userId,
+                createdAt: now,
+                updatedAt: now,
+            };
+            await db.collection('production_sequences').insertOne({ ...sequence });
+            res.status(201).json({ sequence });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    router.patch('/projects/:projectId/production/sequences/:seqId', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId, seqId } = req.params;
+            const project = await Project.findOne({ _id: projectId });
+            if (!project)
+                return res.status(404).json({ message: 'Project not found' });
+            if (!(0, auth_1.isProjectMember)(project, auth.userId))
+                return res.status(403).json({ message: 'Unauthorized' });
+            const db = getDb();
+            if (!db)
+                return res.status(500).json({ message: 'Database not available' });
+            const { name, description, order } = req.body;
+            const $set = { updatedAt: new Date() };
+            if (name !== undefined)
+                $set.name = name;
+            if (description !== undefined)
+                $set.description = description;
+            if (order !== undefined)
+                $set.order = order;
+            const result = await db.collection('production_sequences').findOneAndUpdate({ id: seqId, projectId }, { $set }, { returnDocument: 'after' });
+            if (!result)
+                return res.status(404).json({ message: 'Sequence not found' });
+            res.json({ sequence: result });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    router.delete('/projects/:projectId/production/sequences/:seqId', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId, seqId } = req.params;
+            const project = await Project.findOne({ _id: projectId });
+            if (!project)
+                return res.status(404).json({ message: 'Project not found' });
+            if (!(0, auth_1.isProjectMember)(project, auth.userId))
+                return res.status(403).json({ message: 'Unauthorized' });
+            const db = getDb();
+            if (!db)
+                return res.status(500).json({ message: 'Database not available' });
+            await db.collection('production_sequences').deleteOne({ id: seqId, projectId });
+            await db.collection('production_shots').deleteMany({ sequenceId: seqId, projectId });
+            res.json({ message: 'Sequence deleted' });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    // ── Shots ──────────────────────────────────────────────────────────────────
+    router.get('/projects/:projectId/production/sequences/:seqId/shots', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId, seqId } = req.params;
+            const project = await Project.findOne({ _id: projectId });
+            if (!project)
+                return res.status(404).json({ message: 'Project not found' });
+            if (!(0, auth_1.isProjectMember)(project, auth.userId))
+                return res.status(403).json({ message: 'Unauthorized' });
+            const db = getDb();
+            if (!db)
+                return res.status(500).json({ message: 'Database not available' });
+            const shots = await db.collection('production_shots')
+                .find({ sequenceId: seqId, projectId })
+                .sort({ order: 1, createdAt: 1 })
+                .toArray();
+            res.json({ shots });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    router.post('/projects/:projectId/production/sequences/:seqId/shots', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId, seqId } = req.params;
+            const { name, description, status, assignedTo, assetId, exportId, dueDate, order } = req.body;
+            if (!name)
+                return res.status(400).json({ message: 'name is required' });
+            const project = await Project.findOne({ _id: projectId });
+            if (!project)
+                return res.status(404).json({ message: 'Project not found' });
+            if (!(0, auth_1.isProjectMember)(project, auth.userId))
+                return res.status(403).json({ message: 'Unauthorized' });
+            const db = getDb();
+            if (!db)
+                return res.status(500).json({ message: 'Database not available' });
+            const now = new Date();
+            const shot = {
+                id: crypto_1.default.randomUUID(),
+                sequenceId: seqId,
+                projectId,
+                name,
+                description: description ?? null,
+                order: order ?? 0,
+                status: status ?? 'todo',
+                assignedTo: assignedTo ?? [],
+                assetId: assetId ?? null,
+                exportId: exportId ?? null,
+                dueDate: dueDate ? new Date(dueDate) : null,
+                createdBy: auth.userId,
+                createdAt: now,
+                updatedAt: now,
+            };
+            await db.collection('production_shots').insertOne({ ...shot });
+            res.status(201).json({ shot });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    router.patch('/projects/:projectId/production/shots/:shotId', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId, shotId } = req.params;
+            const project = await Project.findOne({ _id: projectId });
+            if (!project)
+                return res.status(404).json({ message: 'Project not found' });
+            if (!(0, auth_1.isProjectMember)(project, auth.userId))
+                return res.status(403).json({ message: 'Unauthorized' });
+            const db = getDb();
+            if (!db)
+                return res.status(500).json({ message: 'Database not available' });
+            const { name, description, status, assignedTo, assetId, exportId, dueDate, order } = req.body;
+            const $set = { updatedAt: new Date() };
+            if (name !== undefined)
+                $set.name = name;
+            if (description !== undefined)
+                $set.description = description;
+            if (status !== undefined)
+                $set.status = status;
+            if (assignedTo !== undefined)
+                $set.assignedTo = assignedTo;
+            if (assetId !== undefined)
+                $set.assetId = assetId;
+            if (exportId !== undefined)
+                $set.exportId = exportId;
+            if (dueDate !== undefined)
+                $set.dueDate = dueDate ? new Date(dueDate) : null;
+            if (order !== undefined)
+                $set.order = order;
+            const result = await db.collection('production_shots').findOneAndUpdate({ id: shotId, projectId }, { $set }, { returnDocument: 'after' });
+            if (!result)
+                return res.status(404).json({ message: 'Shot not found' });
+            res.json({ shot: result });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    router.delete('/projects/:projectId/production/shots/:shotId', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId, shotId } = req.params;
+            const project = await Project.findOne({ _id: projectId });
+            if (!project)
+                return res.status(404).json({ message: 'Project not found' });
+            if (!(0, auth_1.isProjectMember)(project, auth.userId))
+                return res.status(403).json({ message: 'Unauthorized' });
+            const db = getDb();
+            if (!db)
+                return res.status(500).json({ message: 'Database not available' });
+            await db.collection('production_shots').deleteOne({ id: shotId, projectId });
+            await db.collection('production_tasks').deleteMany({ shotId, projectId });
+            res.json({ message: 'Shot deleted' });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    // ── Tasks ──────────────────────────────────────────────────────────────────
+    router.get('/projects/:projectId/production/shots/:shotId/tasks', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId, shotId } = req.params;
+            const project = await Project.findOne({ _id: projectId });
+            if (!project)
+                return res.status(404).json({ message: 'Project not found' });
+            if (!(0, auth_1.isProjectMember)(project, auth.userId))
+                return res.status(403).json({ message: 'Unauthorized' });
+            const db = getDb();
+            if (!db)
+                return res.status(500).json({ message: 'Database not available' });
+            const tasks = await db.collection('production_tasks')
+                .find({ shotId, projectId })
+                .sort({ createdAt: 1 })
+                .toArray();
+            res.json({ tasks });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    router.post('/projects/:projectId/production/shots/:shotId/tasks', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId, shotId } = req.params;
+            const { name, status, priority, assignedTo, dueDate, notes } = req.body;
+            if (!name)
+                return res.status(400).json({ message: 'name is required' });
+            const project = await Project.findOne({ _id: projectId });
+            if (!project)
+                return res.status(404).json({ message: 'Project not found' });
+            if (!(0, auth_1.isProjectMember)(project, auth.userId))
+                return res.status(403).json({ message: 'Unauthorized' });
+            const db = getDb();
+            if (!db)
+                return res.status(500).json({ message: 'Database not available' });
+            const now = new Date();
+            const task = {
+                id: crypto_1.default.randomUUID(),
+                shotId,
+                projectId,
+                name,
+                status: status ?? 'todo',
+                priority: priority ?? 'medium',
+                assignedTo: assignedTo ?? null,
+                dueDate: dueDate ? new Date(dueDate) : null,
+                notes: notes ?? null,
+                createdBy: auth.userId,
+                createdAt: now,
+                updatedAt: now,
+            };
+            await db.collection('production_tasks').insertOne({ ...task });
+            res.status(201).json({ task });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    router.patch('/projects/:projectId/production/shots/:shotId/tasks/:taskId', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId, shotId, taskId } = req.params;
+            const project = await Project.findOne({ _id: projectId });
+            if (!project)
+                return res.status(404).json({ message: 'Project not found' });
+            if (!(0, auth_1.isProjectMember)(project, auth.userId))
+                return res.status(403).json({ message: 'Unauthorized' });
+            const db = getDb();
+            if (!db)
+                return res.status(500).json({ message: 'Database not available' });
+            const { name, status, priority, assignedTo, dueDate, notes } = req.body;
+            const $set = { updatedAt: new Date() };
+            if (name !== undefined)
+                $set.name = name;
+            if (status !== undefined)
+                $set.status = status;
+            if (priority !== undefined)
+                $set.priority = priority;
+            if (assignedTo !== undefined)
+                $set.assignedTo = assignedTo;
+            if (dueDate !== undefined)
+                $set.dueDate = dueDate ? new Date(dueDate) : null;
+            if (notes !== undefined)
+                $set.notes = notes;
+            const result = await db.collection('production_tasks').findOneAndUpdate({ id: taskId, shotId, projectId }, { $set }, { returnDocument: 'after' });
+            if (!result)
+                return res.status(404).json({ message: 'Task not found' });
+            res.json({ task: result });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    router.delete('/projects/:projectId/production/shots/:shotId/tasks/:taskId', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId, shotId, taskId } = req.params;
+            const project = await Project.findOne({ _id: projectId });
+            if (!project)
+                return res.status(404).json({ message: 'Project not found' });
+            if (!(0, auth_1.isProjectMember)(project, auth.userId))
+                return res.status(403).json({ message: 'Unauthorized' });
+            const db = getDb();
+            if (!db)
+                return res.status(500).json({ message: 'Database not available' });
+            await db.collection('production_tasks').deleteOne({ id: taskId, shotId, projectId });
+            res.json({ message: 'Task deleted' });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    return router;
+}

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

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