streamby-core 0.28.5 → 0.28.6

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

@@ -24,6 +24,11 @@ const dbConnection_1 = require("./routes/dbConnection");
 const storageConnection_1 = require("./routes/storageConnection");
 const notification_1 = require("./routes/notification");
 const subscription_1 = require("./routes/subscription");
+const media_1 = require("./routes/media");
+const renderFarm_1 = require("./routes/renderFarm");
+const review_1 = require("./routes/review");
+const distribution_1 = require("./routes/distribution");
+const ai_1 = require("./routes/ai");
 function createStreamByRouter(config) {
     const router = express_1.default.Router();
     if (config.encrypt)
@@ -39,6 +44,13 @@ function createStreamByRouter(config) {
         if (nosqlDbIds.length > 0) {
             (0, manager_1.registerModel)('notifications', nosqlDbIds, 'notifications', streambySchema);
             (0, manager_1.registerModel)('storage_files', nosqlDbIds, 'storage_files');
+            (0, manager_1.registerModel)('media_metadata', nosqlDbIds, 'media_metadata');
+            (0, manager_1.registerModel)('asset_versions', nosqlDbIds, 'asset_versions');
+            (0, manager_1.registerModel)('asset_dependency_graphs', nosqlDbIds, 'asset_dependency_graphs');
+            (0, manager_1.registerModel)('review_sessions', nosqlDbIds, 'review_sessions');
+            (0, manager_1.registerModel)('annotations', nosqlDbIds, 'annotations');
+            (0, manager_1.registerModel)('qc_reports', nosqlDbIds, 'qc_reports');
+            (0, manager_1.registerModel)('generative_jobs', nosqlDbIds, 'generative_jobs');
         }
         const mainDb = config.databases.find(db => db.main);
         if (mainDb) {
@@ -64,5 +76,10 @@ function createStreamByRouter(config) {
     router.use((0, storageConnection_1.storageConnectionRouter)(config));
     router.use((0, notification_1.notificationRouter)(config));
     router.use((0, subscription_1.subscriptionRouter)(config));
+    router.use((0, media_1.mediaRouter)(config));
+    router.use((0, renderFarm_1.renderFarmRouter)(config));
+    router.use((0, review_1.reviewRouter)(config));
+    router.use((0, distribution_1.distributionRouter)(config));
+    router.use((0, ai_1.aiRouter)(config));
     return router;
 }

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

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

package/dist/middleware/routes/ai.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.aiRouter = aiRouter;
+const express_1 = require("express");
+const manager_1 = require("../../models/manager");
+const auth_1 = require("../../utils/auth");
+const jobQueue_1 = require("../../services/jobQueue");
+const aiProcessor_1 = require("../../services/aiProcessor");
+const AVAILABLE_NODE_TYPES = [
+    'dataSourceNode', 'jsonInputNode', 'apiConnectionNode',
+    'processNode', 'filterNode',
+    'ingestNode', 'transcodeNode', 'captionNode', 'thumbnailNode',
+    'renderJobNode', 'formatConvertNode', 'lodNode', 'assetDependencyNode',
+    'reviewGateNode', 'annotationNode',
+    'qcCheckNode', 'deliverableNode', 'distributionNode',
+    'transcriptionNode', 'upscaleNode', 'proceduralAssetNode', 'pipelineSuggestNode',
+];
+function aiRouter(_config) {
+    const router = (0, express_1.Router)();
+    const Project = (0, manager_1.getModel)('projects');
+    // POST /projects/:projectId/jobs/transcription
+    router.post('/projects/:projectId/jobs/transcription', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId } = req.params;
+            const { fileId, model, sourceLanguage, outputFormats, provider, credentialId } = 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)('transcription', auth.userId, projectId, { fileId, model, sourceLanguage, outputFormats, provider, credentialId });
+            setImmediate(() => (0, aiProcessor_1.runTranscriptionJob)(job.jobId, fileId, projectId, { model, sourceLanguage, outputFormats, provider, credentialId }));
+            res.status(202).json({ jobId: job.jobId, status: job.status });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    // POST /projects/:projectId/jobs/upscale
+    router.post('/projects/:projectId/jobs/upscale', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId } = req.params;
+            const { fileId, scale, model, mode, credentialId } = 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)('upscale', auth.userId, projectId, { fileId, scale, model, mode, credentialId });
+            setImmediate(() => (0, aiProcessor_1.runUpscaleJob)(job.jobId, fileId, projectId, { scale, model, mode, credentialId }));
+            res.status(202).json({ jobId: job.jobId, status: job.status });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    // POST /projects/:projectId/jobs/generate-asset
+    router.post('/projects/:projectId/jobs/generate-asset', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId } = req.params;
+            const { assetType, provider, prompt, seed, credentialId } = req.body;
+            if (!prompt)
+                return res.status(400).json({ message: 'prompt 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)('generate-asset', auth.userId, projectId, { assetType, provider, prompt, seed, credentialId });
+            setImmediate(() => (0, aiProcessor_1.runGenerateAssetJob)(job.jobId, projectId, { assetType, provider, prompt, seed, credentialId }));
+            res.status(202).json({ jobId: job.jobId, status: job.status });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    // POST /projects/:projectId/pipeline-suggest
+    router.post('/projects/:projectId/pipeline-suggest', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId } = req.params;
+            const { nodeSchema } = req.body;
+            if (!nodeSchema?.nodes)
+                return res.status(400).json({ message: 'nodeSchema 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 suggestion = await (0, aiProcessor_1.buildPipelineSuggestion)(nodeSchema, AVAILABLE_NODE_TYPES);
+            res.json({ suggestion });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    return router;
+}

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

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

package/dist/middleware/routes/distribution.js

@@ -0,0 +1,192 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.distributionRouter = distributionRouter;
+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 broadcastDeliveryUpdate(userId, payload) {
+    (0, wsHub_1.emitToUser)(userId, { type: 'jobEvent', data: payload });
+}
+function distributionRouter(_config) {
+    const router = (0, express_1.Router)();
+    const Project = (0, manager_1.getModel)('projects');
+    const Export = (0, manager_1.getModel)('exports');
+    // ─── Distribution Connections ─────────────────────────────────────────────────
+    router.get('/projects/:projectId/distribution-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.distributionConnections ?? [] });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    router.post('/projects/:projectId/distribution-connections', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId } = req.params;
+            const { name, target, credentialId, config, description } = req.body;
+            if (!name || !target)
+                return res.status(400).json({ message: 'name and target 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,
+                target,
+                credentialId,
+                config: config ?? {},
+                description,
+                projectId,
+                createdAt: new Date(),
+            };
+            await Project.update({ _id: projectId }, { $push: { distributionConnections: connection } });
+            res.status(201).json({ connection });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    router.delete('/projects/:projectId/distribution-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: { distributionConnections: { id: connectionId } } });
+            res.json({ message: 'Connection deleted' });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    // ─── Publish Deliverable ──────────────────────────────────────────────────────
+    router.post('/projects/:projectId/deliverables/:exportId/publish', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId, exportId } = req.params;
+            const { targets } = req.body;
+            if (!targets?.length)
+                return res.status(400).json({ message: 'targets array 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 exportDoc = await Export.findOne({ id: exportId, projectId });
+            if (!exportDoc)
+                return res.status(404).json({ message: 'Deliverable not found' });
+            const connections = project.distributionConnections ?? [];
+            const deliveryTargets = targets.map(t => {
+                const conn = connections.find(c => c.id === t.connectionId);
+                return {
+                    connectionId: t.connectionId,
+                    target: conn?.target ?? 'customWebhook',
+                    channel: t.channel,
+                    status: 'pending',
+                };
+            });
+            const now = new Date();
+            await Export.update({ id: exportId, projectId }, {
+                $set: {
+                    deliverableTargets: deliveryTargets,
+                    publishedAt: now,
+                    publishedBy: auth.userId,
+                    updatedAt: now,
+                },
+            });
+            // Dispatch async — actual upload/API call happens in the host worker
+            setImmediate(() => {
+                for (const dt of deliveryTargets) {
+                    broadcastDeliveryUpdate(auth.userId, {
+                        jobId: crypto_1.default.randomUUID(),
+                        jobType: 'distribute',
+                        stage: 'queued',
+                        progress: 5,
+                        assetId: exportId,
+                        message: `Queued publish to ${dt.target}`,
+                    });
+                }
+            });
+            res.status(202).json({ deliverableTargets: deliveryTargets, publishedAt: now });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    // ─── QC Reports ───────────────────────────────────────────────────────────────
+    router.get('/projects/:projectId/assets/:assetId/qc-report', 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 report = await db.collection('qc_reports').findOne({ assetId, projectId }, { sort: { generatedAt: -1 } });
+            res.json({ report: report ?? null });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    router.post('/projects/:projectId/assets/:assetId/qc-report', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId, assetId } = req.params;
+            const { checks } = req.body;
+            if (!Array.isArray(checks))
+                return res.status(400).json({ message: 'checks array 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 overallPassed = checks.every((c) => c.passed === true);
+            const report = {
+                assetId,
+                projectId,
+                checks,
+                overallPassed,
+                generatedAt: new Date(),
+            };
+            await db.collection('qc_reports').insertOne({ ...report });
+            res.status(201).json({ report });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    return router;
+}

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

@@ -0,0 +1,5 @@
+import { Router } from 'express';
+import { StreamByConfig, StorageAdapter } from '../../types';
+export declare function mediaRouter(config: StreamByConfig & {
+    adapter?: StorageAdapter;
+}): Router;