streamby-core 0.28.5 → 0.28.6

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

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

package/dist/middleware/routes/renderFarm.js

@@ -0,0 +1,158 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderFarmRouter = renderFarmRouter;
+const express_1 = require("express");
+const manager_1 = require("../../models/manager");
+const auth_1 = require("../../utils/auth");
+const jobQueue_1 = require("../../services/jobQueue");
+const vfxProcessor_1 = require("../../services/vfxProcessor");
+const crypto_1 = __importDefault(require("crypto"));
+function renderFarmRouter(_config) {
+    const router = (0, express_1.Router)();
+    const Project = (0, manager_1.getModel)('projects');
+    // ─── Render Farm Connections ─────────────────────────────────────────────────
+    router.get('/projects/:projectId/render-farm-connections', 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' });
+            res.json({ connections: project.renderFarmConnections ?? [] });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    router.post('/projects/:projectId/render-farm-connections', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId } = req.params;
+            const { name, provider, apiUrl, credentialId, description } = req.body;
+            if (!name || !provider || !apiUrl) {
+                return res.status(400).json({ message: 'name, provider and apiUrl are 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 connection = {
+                id: crypto_1.default.randomUUID(),
+                name,
+                provider,
+                apiUrl,
+                credentialId,
+                description,
+                projectId,
+                createdAt: new Date(),
+            };
+            await Project.update({ _id: projectId }, { $push: { renderFarmConnections: connection } });
+            res.status(201).json({ connection });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    router.delete('/projects/:projectId/render-farm-connections/:connectionId', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId, connectionId } = 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' });
+            await Project.update({ _id: projectId }, { $pull: { renderFarmConnections: { id: connectionId } } });
+            res.json({ message: 'Connection deleted' });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    // ─── VFX Jobs ────────────────────────────────────────────────────────────────
+    router.post('/projects/:projectId/jobs/render', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId } = req.params;
+            const { fileId, renderer, renderFarmConnectionId, frameRange, resolution, samples, outputFormat } = 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)('render', auth.userId, projectId, { fileId, renderer, renderFarmConnectionId, frameRange, resolution, samples, outputFormat });
+            setImmediate(() => (0, vfxProcessor_1.runRenderJob)(job.jobId, fileId, projectId, { renderer, renderFarmConnectionId, frameRange, resolution, samples, outputFormat }));
+            res.status(202).json({ jobId: job.jobId, status: job.status });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    router.post('/projects/:projectId/jobs/format-convert', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId } = req.params;
+            const { fileId, inputFormat, outputFormat, applyTransforms, embedTextures } = 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)('format-convert', auth.userId, projectId, { fileId, inputFormat, outputFormat, applyTransforms, embedTextures });
+            setImmediate(() => (0, vfxProcessor_1.runFormatConvertJob)(job.jobId, fileId, projectId, { inputFormat, outputFormat, applyTransforms, embedTextures }));
+            res.status(202).json({ jobId: job.jobId, status: job.status });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    router.post('/projects/:projectId/jobs/lod', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId } = req.params;
+            const { fileId, levels, reductionRatios, algorithm, outputFormat } = 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)('lod', auth.userId, projectId, { fileId, levels, reductionRatios, algorithm, outputFormat });
+            setImmediate(() => (0, vfxProcessor_1.runLodJob)(job.jobId, fileId, projectId, { levels, reductionRatios, algorithm, outputFormat }));
+            res.status(202).json({ jobId: job.jobId, status: job.status });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    // ─── Asset Dependency Graph ──────────────────────────────────────────────────
+    router.get('/projects/:projectId/assets/:fileId/dependency-graph', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId, fileId } = req.params;
+            const maxDepth = Number(req.query.maxDepth ?? 5);
+            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 graph = await (0, vfxProcessor_1.resolveAssetDependencyGraph)(projectId, fileId, maxDepth);
+            res.json({ graph });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    return router;
+}

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

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

package/dist/middleware/routes/review.js

@@ -0,0 +1,240 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reviewRouter = reviewRouter;
+const express_1 = require("express");
+const manager_1 = require("../../models/manager");
+const auth_1 = require("../../utils/auth");
+const wsHub_1 = require("../../services/wsHub");
+const connectionManager_1 = require("../../adapters/database/connectionManager");
+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 broadcastReviewUpdate(review, project) {
+    const members = project.members ?? [];
+    for (const m of members) {
+        (0, wsHub_1.emitToUser)(m.userId, { type: 'reviewEvent', data: review });
+    }
+}
+function reviewRouter(_config) {
+    const router = (0, express_1.Router)();
+    const Project = (0, manager_1.getModel)('projects');
+    // GET /projects/:projectId/reviews
+    router.get('/projects/:projectId/reviews', 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 reviews = await db.collection('review_sessions')
+                .find({ projectId })
+                .sort({ createdAt: -1 })
+                .toArray();
+            res.json({ reviews });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    // POST /projects/:projectId/reviews
+    router.post('/projects/:projectId/reviews', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId } = req.params;
+            const { assetId, assetVersionId, requiredApprovers, deadline } = req.body;
+            if (!assetId || !assetVersionId) {
+                return res.status(400).json({ message: 'assetId and assetVersionId are 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 review = {
+                id: crypto_1.default.randomUUID(),
+                projectId,
+                assetId,
+                assetVersionId,
+                status: 'open',
+                requiredApprovers: requiredApprovers ?? 1,
+                approvals: [],
+                deadline: deadline ? new Date(deadline) : undefined,
+                createdAt: now,
+                updatedAt: now,
+            };
+            await db.collection('review_sessions').insertOne({ ...review });
+            broadcastReviewUpdate(review, project);
+            res.status(201).json({ review });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    // GET /projects/:projectId/reviews/:reviewId
+    router.get('/projects/:projectId/reviews/:reviewId', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId, reviewId } = 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 review = await db.collection('review_sessions').findOne({ id: reviewId, projectId });
+            if (!review)
+                return res.status(404).json({ message: 'Review not found' });
+            res.json({ review });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    // POST /projects/:projectId/reviews/:reviewId/decision
+    router.post('/projects/:projectId/reviews/:reviewId/decision', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId, reviewId } = req.params;
+            const { decision, comment } = req.body;
+            if (decision !== 'approve' && decision !== 'reject') {
+                return res.status(400).json({ message: 'decision must be approve or reject' });
+            }
+            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 col = db.collection('review_sessions');
+            const review = await col.findOne({ id: reviewId, projectId });
+            if (!review)
+                return res.status(404).json({ message: 'Review not found' });
+            if (review.status !== 'open')
+                return res.status(409).json({ message: `Review is already ${review.status}` });
+            // Remove any prior decision from this user, then add the new one
+            const approvals = (review.approvals ?? []).filter(a => a.userId !== auth.userId);
+            approvals.push({
+                userId: auth.userId,
+                username: auth.username ?? auth.userId,
+                decision,
+                comment,
+                at: new Date(),
+            });
+            const approveCount = approvals.filter(a => a.decision === 'approve').length;
+            const hasRejection = approvals.some(a => a.decision === 'reject');
+            let status = 'open';
+            if (hasRejection)
+                status = 'rejected';
+            else if (approveCount >= review.requiredApprovers)
+                status = 'approved';
+            const updatedAt = new Date();
+            await col.updateOne({ id: reviewId, projectId }, { $set: { approvals, status, updatedAt } });
+            const updated = { ...review, approvals, status, updatedAt };
+            broadcastReviewUpdate(updated, project);
+            res.json({ review: updated });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    // ─── Annotations ─────────────────────────────────────────────────────────────
+    router.get('/projects/:projectId/assets/:assetId/versions/:versionId/annotations', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId, assetId, versionId } = 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 annotations = await db.collection('annotations')
+                .find({ assetId, assetVersionId: versionId, projectId })
+                .sort({ createdAt: 1 })
+                .toArray();
+            res.json({ annotations });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    router.post('/projects/:projectId/assets/:assetId/versions/:versionId/annotations', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId, assetId, versionId } = req.params;
+            const { type, timecode, position3d, regionRect, text } = req.body;
+            if (!type || !text)
+                return res.status(400).json({ message: 'type and text are 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 annotation = {
+                id: crypto_1.default.randomUUID(),
+                assetId,
+                assetVersionId: versionId,
+                projectId,
+                authorId: auth.userId,
+                authorUsername: auth.username ?? auth.userId,
+                type,
+                timecode,
+                position3d,
+                regionRect,
+                text,
+                resolved: false,
+                createdAt: new Date(),
+            };
+            await db.collection('annotations').insertOne({ ...annotation });
+            res.status(201).json({ annotation });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    router.patch('/projects/:projectId/assets/:assetId/versions/:versionId/annotations/:annotationId/resolve', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId, assetId, versionId, annotationId } = 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('annotations').updateOne({ id: annotationId, assetId, assetVersionId: versionId, projectId }, { $set: { resolved: true, resolvedBy: auth.userId } });
+            res.json({ message: 'Annotation resolved' });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    return router;
+}

package/dist/models/Model.js

@@ -45,11 +45,11 @@ class Model {
                     // 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 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 => ({
@@ -219,10 +219,10 @@ class Model {
         else {
             const matchKey = value.id !== undefined ? 'id' : Object.keys(value)[0];
             const matchVal = String(value[matchKey]);
-            await connection.query(`UPDATE ${tbl} SET "${field}" = (
-          SELECT COALESCE(jsonb_agg(elem), '[]'::jsonb)
-          FROM jsonb_array_elements("${field}") elem
-          WHERE elem->>'${matchKey}' != $1
+            await connection.query(`UPDATE ${tbl} SET "${field}" = (
+          SELECT COALESCE(jsonb_agg(elem), '[]'::jsonb)
+          FROM jsonb_array_elements("${field}") elem
+          WHERE elem->>'${matchKey}' != $1
         ) WHERE id = $2`, [matchVal, id]);
         }
     }

package/dist/services/aiProcessor.d.ts

@@ -0,0 +1,25 @@
+import { PipelineSuggestion } from '../types';
+export declare function runTranscriptionJob(jobId: string, fileId: string, projectId: string, options: {
+    model?: string;
+    sourceLanguage?: string;
+    outputFormats?: string[];
+    provider?: string;
+    credentialId?: string;
+}): Promise<void>;
+export declare function runUpscaleJob(jobId: string, fileId: string, projectId: string, options: {
+    scale?: number;
+    model?: string;
+    mode?: 'images' | 'video';
+    credentialId?: string;
+}): Promise<void>;
+export declare function runGenerateAssetJob(jobId: string, projectId: string, options: {
+    assetType?: 'mesh' | 'texture' | 'audio';
+    provider?: string;
+    prompt: string;
+    seed?: number;
+    credentialId?: string;
+}): Promise<void>;
+export declare function buildPipelineSuggestion(nodeSchema: {
+    nodes: any[];
+    edges: any[];
+}, availableNodeTypes: string[]): Promise<PipelineSuggestion>;