streamby-core 0.28.6 → 0.29.1

package/dist/adapters/database/connectionManager.js

@@ -43,83 +43,83 @@ const getConnection = (id) => {
 exports.getConnection = getConnection;
 const ensureTablesExist = async (pool) => {
     try {
-        await pool.query(`
-      CREATE SCHEMA IF NOT EXISTS streamby;
-      CREATE EXTENSION IF NOT EXISTS "uuid-ossp";
+        await pool.query(`
+      CREATE SCHEMA IF NOT EXISTS streamby;
+      CREATE EXTENSION IF NOT EXISTS "uuid-ossp";
     `);
         // Migrate id column from UUID to TEXT if it was created with the old schema
-        await pool.query(`
-      DO $$ BEGIN
-        ALTER TABLE streamby.projects ALTER COLUMN id TYPE TEXT USING id::text;
-        ALTER TABLE streamby.projects ALTER COLUMN id SET DEFAULT uuid_generate_v4()::text;
-      EXCEPTION WHEN OTHERS THEN NULL; END $$;
+        await pool.query(`
+      DO $$ BEGIN
+        ALTER TABLE streamby.projects ALTER COLUMN id TYPE TEXT USING id::text;
+        ALTER TABLE streamby.projects ALTER COLUMN id SET DEFAULT uuid_generate_v4()::text;
+      EXCEPTION WHEN OTHERS THEN NULL; END $$;
     `);
-        await pool.query(`
-      CREATE TABLE IF NOT EXISTS streamby.projects (
-        id               TEXT PRIMARY KEY DEFAULT uuid_generate_v4()::text,
-        name             VARCHAR(255) NOT NULL,
-        description      TEXT,
-        image            TEXT,
-        "allowedOrigin"  JSONB DEFAULT '[]',
-        exports          JSONB DEFAULT '[]',
-        credentials      JSONB DEFAULT '[]',
-        "apiConnections" JSONB DEFAULT '[]',
-        "dbConnections"  JSONB DEFAULT '[]',
-        "dbType"         VARCHAR(50) NOT NULL DEFAULT 'sql',
-        "createdAt"      TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
-        "updatedAt"      TIMESTAMP WITH TIME ZONE DEFAULT NOW()
-      );
+        await pool.query(`
+      CREATE TABLE IF NOT EXISTS streamby.projects (
+        id               TEXT PRIMARY KEY DEFAULT uuid_generate_v4()::text,
+        name             VARCHAR(255) NOT NULL,
+        description      TEXT,
+        image            TEXT,
+        "allowedOrigin"  JSONB DEFAULT '[]',
+        exports          JSONB DEFAULT '[]',
+        credentials      JSONB DEFAULT '[]',
+        "apiConnections" JSONB DEFAULT '[]',
+        "dbConnections"  JSONB DEFAULT '[]',
+        "dbType"         VARCHAR(50) NOT NULL DEFAULT 'sql',
+        "createdAt"      TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
+        "updatedAt"      TIMESTAMP WITH TIME ZONE DEFAULT NOW()
+      );
     `);
         console.log('✅ "projects" table ensured to exist.');
         // Add JSONB columns to existing tables that predate this schema version
-        await pool.query(`
-      ALTER TABLE streamby.projects ADD COLUMN IF NOT EXISTS "allowedOrigin"  JSONB DEFAULT '[]';
-      ALTER TABLE streamby.projects ADD COLUMN IF NOT EXISTS exports          JSONB DEFAULT '[]';
-      ALTER TABLE streamby.projects ADD COLUMN IF NOT EXISTS credentials      JSONB DEFAULT '[]';
-      ALTER TABLE streamby.projects ADD COLUMN IF NOT EXISTS "apiConnections" JSONB DEFAULT '[]';
-      ALTER TABLE streamby.projects ADD COLUMN IF NOT EXISTS "dbConnections"  JSONB DEFAULT '[]';
+        await pool.query(`
+      ALTER TABLE streamby.projects ADD COLUMN IF NOT EXISTS "allowedOrigin"  JSONB DEFAULT '[]';
+      ALTER TABLE streamby.projects ADD COLUMN IF NOT EXISTS exports          JSONB DEFAULT '[]';
+      ALTER TABLE streamby.projects ADD COLUMN IF NOT EXISTS credentials      JSONB DEFAULT '[]';
+      ALTER TABLE streamby.projects ADD COLUMN IF NOT EXISTS "apiConnections" JSONB DEFAULT '[]';
+      ALTER TABLE streamby.projects ADD COLUMN IF NOT EXISTS "dbConnections"  JSONB DEFAULT '[]';
     `);
         // Ensure dbType exists with a non-null default
-        await pool.query(`
-      ALTER TABLE streamby.projects ADD COLUMN IF NOT EXISTS "dbType" VARCHAR(50) NOT NULL DEFAULT 'sql';
+        await pool.query(`
+      ALTER TABLE streamby.projects ADD COLUMN IF NOT EXISTS "dbType" VARCHAR(50) NOT NULL DEFAULT 'sql';
     `);
-        await pool.query(`
-      CREATE TABLE IF NOT EXISTS streamby.project_members (
-        id           TEXT PRIMARY KEY DEFAULT uuid_generate_v4()::text,
-        "projectId"  TEXT NOT NULL REFERENCES streamby.projects(id) ON DELETE CASCADE,
-        "userId"     VARCHAR(255) NOT NULL,
-        role         VARCHAR(255) NOT NULL DEFAULT 'member',
-        status       VARCHAR(50) NOT NULL DEFAULT 'active',
-        archived     BOOLEAN NOT NULL DEFAULT FALSE,
-        "archivedBy" VARCHAR(255),
-        "archivedAt" TIMESTAMP WITH TIME ZONE,
-        "createdAt"  TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
-        "updatedAt"  TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
-        UNIQUE ("projectId", "userId")
-      );
+        await pool.query(`
+      CREATE TABLE IF NOT EXISTS streamby.project_members (
+        id           TEXT PRIMARY KEY DEFAULT uuid_generate_v4()::text,
+        "projectId"  TEXT NOT NULL REFERENCES streamby.projects(id) ON DELETE CASCADE,
+        "userId"     VARCHAR(255) NOT NULL,
+        role         VARCHAR(255) NOT NULL DEFAULT 'member',
+        status       VARCHAR(50) NOT NULL DEFAULT 'active',
+        archived     BOOLEAN NOT NULL DEFAULT FALSE,
+        "archivedBy" VARCHAR(255),
+        "archivedAt" TIMESTAMP WITH TIME ZONE,
+        "createdAt"  TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
+        "updatedAt"  TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
+        UNIQUE ("projectId", "userId")
+      );
     `);
-        await pool.query(`
-      ALTER TABLE streamby.project_members ADD COLUMN IF NOT EXISTS status VARCHAR(50) NOT NULL DEFAULT 'active';
+        await pool.query(`
+      ALTER TABLE streamby.project_members ADD COLUMN IF NOT EXISTS status VARCHAR(50) NOT NULL DEFAULT 'active';
     `);
         console.log('✅ "project_members" table ensured to exist.');
         // Migrate projectId FK column from UUID to TEXT if table predates this schema version
-        await pool.query(`
-      DO $$ BEGIN
-        ALTER TABLE streamby.project_members DROP CONSTRAINT IF EXISTS project_members_projectId_fkey;
-        ALTER TABLE streamby.project_members ALTER COLUMN "projectId" TYPE TEXT;
-        ALTER TABLE streamby.project_members ADD CONSTRAINT project_members_projectid_fkey
-          FOREIGN KEY ("projectId") REFERENCES streamby.projects(id) ON DELETE CASCADE;
-      EXCEPTION WHEN OTHERS THEN NULL; END $$;
+        await pool.query(`
+      DO $$ BEGIN
+        ALTER TABLE streamby.project_members DROP CONSTRAINT IF EXISTS project_members_projectId_fkey;
+        ALTER TABLE streamby.project_members ALTER COLUMN "projectId" TYPE TEXT;
+        ALTER TABLE streamby.project_members ADD CONSTRAINT project_members_projectid_fkey
+          FOREIGN KEY ("projectId") REFERENCES streamby.projects(id) ON DELETE CASCADE;
+      EXCEPTION WHEN OTHERS THEN NULL; END $$;
     `);
-        await pool.query(`
-      CREATE TABLE IF NOT EXISTS streamby.exports (
-        id          TEXT PRIMARY KEY DEFAULT uuid_generate_v4()::text,
-        "projectId" TEXT NOT NULL REFERENCES streamby.projects(id) ON DELETE CASCADE,
-        status      VARCHAR(50) NOT NULL DEFAULT 'pending',
-        "filePath"  TEXT,
-        "createdAt" TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
-        "updatedAt" TIMESTAMP WITH TIME ZONE DEFAULT NOW()
-      );
+        await pool.query(`
+      CREATE TABLE IF NOT EXISTS streamby.exports (
+        id          TEXT PRIMARY KEY DEFAULT uuid_generate_v4()::text,
+        "projectId" TEXT NOT NULL REFERENCES streamby.projects(id) ON DELETE CASCADE,
+        status      VARCHAR(50) NOT NULL DEFAULT 'pending',
+        "filePath"  TEXT,
+        "createdAt" TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
+        "updatedAt" TIMESTAMP WITH TIME ZONE DEFAULT NOW()
+      );
     `);
         console.log('✅ "exports" table ensured to exist.');
     }

package/dist/adapters/database/sql.js

@@ -10,7 +10,7 @@ function serializeForPg(v) {
 }
 const createSQLExportTable = async (connection, projectId, exportName, nodeSchema) => {
     const exportId = (0, crypto_1.randomUUID)();
-    await connection.query(`INSERT INTO "exports" (id, "projectId", node_schema, name, method, created_at, updated_at)
+    await connection.query(`INSERT INTO "exports" (id, "projectId", node_schema, name, method, created_at, updated_at)
      VALUES ($1, $2, $3, $4, 'GET', NOW(), NOW())`, [exportId, projectId, nodeSchema ? JSON.stringify(nodeSchema) : null, exportName]);
     return { exportId };
 };

package/dist/middleware/createRouter.js

@@ -29,6 +29,9 @@ const renderFarm_1 = require("./routes/renderFarm");
 const review_1 = require("./routes/review");
 const distribution_1 = require("./routes/distribution");
 const ai_1 = require("./routes/ai");
+const production_1 = require("./routes/production");
+const rights_1 = require("./routes/rights");
+const workflow_1 = require("./routes/workflow");
 function createStreamByRouter(config) {
     const router = express_1.default.Router();
     if (config.encrypt)
@@ -81,5 +84,8 @@ function createStreamByRouter(config) {
     router.use((0, review_1.reviewRouter)(config));
     router.use((0, distribution_1.distributionRouter)(config));
     router.use((0, ai_1.aiRouter)(config));
+    router.use((0, production_1.productionRouter)(config));
+    router.use((0, rights_1.rightsRouter)(config));
+    router.use((0, workflow_1.workflowRouter)(config));
     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/project.js

@@ -74,7 +74,7 @@ function projectRouter(config) {
             if (auth.role !== 'admin' && auth.role !== 'editor') {
                 return res.status(403).json({ message: 'Permission denied' });
             }
-            const { name, description, image, allowedOrigin, public: isPublic = true } = req.body;
+            const { name, description, image, allowedOrigin, public: isPublic = true, category } = req.body;
             if (isPublic === false && req.subscription === 'freemium') {
                 return res.status(403).json({ error: 'Private projects require a subscriber plan' });
             }
@@ -95,6 +95,7 @@ function projectRouter(config) {
                 image: image || '',
                 allowedOrigin: allowedOrigin || [],
                 public: isPublic,
+                category: category || null,
                 members: [{ userId: auth.userId, username: user.username, role: "admin", status: "active", archived: false }],
             });
             const allProjects = await Project.find({});
@@ -246,7 +247,7 @@ function projectRouter(config) {
             }
             if (project.dbType === 'sql') {
                 const connection = (0, connectionManager_1.getConnection)(config.databases?.find(db => db.main)?.id || '').client;
-                await sql_1.sqlAdapter.update(connection, 'project_members', { projectId: projectId, userId: auth.userId }, { archived: true, archivedBy: auth.userId, archivedAt: new Date() });
+                await sql_1.sqlAdapter.update(connection, 'project_members', { projectId: projectId, userId: auth.userId }, { archived: true, archivedBy: auth.userId, archivedAt: new Date() }, 'streamby');
             }
             else {
                 const memberIndex = project.members.findIndex((member) => member.userId === auth.userId);
@@ -284,7 +285,7 @@ function projectRouter(config) {
             }
             if (project.dbType === 'sql') {
                 const connection = (0, connectionManager_1.getConnection)(config.databases?.find(db => db.main)?.id || '').client;
-                await sql_1.sqlAdapter.update(connection, 'project_members', { projectId: projectId, userId: auth.userId }, { archived: false, archivedBy: null, archivedAt: null });
+                await sql_1.sqlAdapter.update(connection, 'project_members', { projectId: projectId, userId: auth.userId }, { archived: false, archivedBy: null, archivedAt: null }, 'streamby');
             }
             else {
                 const memberIndex = project.members.findIndex((member) => member.userId === auth.userId);

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

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

package/dist/middleware/routes/rights.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rightsRouter = rightsRouter;
+const express_1 = require("express");
+const auth_1 = require("../../utils/auth");
+const connectionManager_1 = require("../../adapters/database/connectionManager");
+const manager_1 = require("../../models/manager");
+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 rightsRouter(_config) {
+    const router = (0, express_1.Router)();
+    const Project = (0, manager_1.getModel)('projects');
+    // GET /projects/:projectId/assets/:assetId/rights
+    router.get('/projects/:projectId/assets/:assetId/rights', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId, assetId } = 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 rights = await db.collection('asset_rights').findOne({ assetId, projectId });
+            res.json({ rights: rights ?? null });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    // PUT /projects/:projectId/assets/:assetId/rights  (upsert)
+    router.put('/projects/:projectId/assets/:assetId/rights', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId, assetId } = 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 { rightsHolder, licenseType, licenseUrl, territory, expiresAt, usageRestrictions, notes } = req.body;
+            const now = new Date();
+            const payload = {
+                assetId,
+                projectId,
+                licenseType: licenseType ?? 'unknown',
+                updatedBy: auth.userId,
+                updatedAt: now,
+            };
+            if (rightsHolder !== undefined)
+                payload.rightsHolder = rightsHolder;
+            if (licenseUrl !== undefined)
+                payload.licenseUrl = licenseUrl;
+            if (territory !== undefined)
+                payload.territory = territory;
+            if (expiresAt !== undefined)
+                payload.expiresAt = expiresAt ? new Date(expiresAt) : null;
+            if (usageRestrictions !== undefined)
+                payload.usageRestrictions = usageRestrictions;
+            if (notes !== undefined)
+                payload.notes = notes;
+            await db.collection('asset_rights').updateOne({ assetId, projectId }, { $set: payload }, { upsert: true });
+            const rights = await db.collection('asset_rights').findOne({ assetId, projectId });
+            res.json({ rights });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    return router;
+}