streamby-core 0.28.5 → 0.28.6

package/dist/services/vfxProcessor.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runRenderJob = runRenderJob;
+exports.runFormatConvertJob = runFormatConvertJob;
+exports.runLodJob = runLodJob;
+exports.resolveAssetDependencyGraph = resolveAssetDependencyGraph;
+const connectionManager_1 = require("../adapters/database/connectionManager");
+const jobQueue_1 = require("./jobQueue");
+function getNosqlDb() {
+    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();
+}
+async function runRenderJob(jobId, fileId, projectId, options) {
+    (0, jobQueue_1.updateJob)(jobId, { status: 'processing', stage: 'resolving', progress: 10, assetId: fileId });
+    try {
+        const db = getNosqlDb();
+        if (!db)
+            throw new Error('Storage database not available');
+        const fileDoc = await db.collection('storage_files').findOne({ fileId, projectId });
+        if (!fileDoc)
+            throw new Error(`File ${fileId} not found`);
+        (0, jobQueue_1.updateJob)(jobId, { stage: 'queued-farm', progress: 20 });
+        // Store pending render task — picked up by the host render farm worker
+        await db.collection('media_metadata').updateOne({ assetId: fileId, projectId }, {
+            $set: {
+                assetId: fileId,
+                projectId,
+                pendingRender: {
+                    renderer: options.renderer ?? 'blender',
+                    renderFarmConnectionId: options.renderFarmConnectionId,
+                    frameRange: options.frameRange ?? '1-1',
+                    resolution: options.resolution ?? '1920x1080',
+                    samples: options.samples ?? 128,
+                    outputFormat: options.outputFormat ?? 'png',
+                    requestedAt: new Date(),
+                },
+                customTags: {},
+                extractedAt: new Date(),
+            },
+        }, { upsert: true });
+        (0, jobQueue_1.updateJob)(jobId, { stage: 'pending-worker', progress: 30 });
+    }
+    catch (err) {
+        (0, jobQueue_1.failJob)(jobId, err.message);
+    }
+}
+async function runFormatConvertJob(jobId, fileId, projectId, options) {
+    (0, jobQueue_1.updateJob)(jobId, { status: 'processing', stage: 'resolving', progress: 10, assetId: fileId });
+    try {
+        const db = getNosqlDb();
+        if (!db)
+            throw new Error('Storage database not available');
+        const fileDoc = await db.collection('storage_files').findOne({ fileId, projectId });
+        if (!fileDoc)
+            throw new Error(`File ${fileId} not found`);
+        (0, jobQueue_1.updateJob)(jobId, { stage: 'queued-convert', progress: 25 });
+        await db.collection('media_metadata').updateOne({ assetId: fileId, projectId }, {
+            $set: {
+                assetId: fileId,
+                projectId,
+                pendingFormatConvert: {
+                    inputFormat: options.inputFormat ?? 'fbx',
+                    outputFormat: options.outputFormat ?? 'glb',
+                    applyTransforms: options.applyTransforms ?? true,
+                    embedTextures: options.embedTextures ?? true,
+                    requestedAt: new Date(),
+                },
+                customTags: {},
+                extractedAt: new Date(),
+            },
+        }, { upsert: true });
+        (0, jobQueue_1.updateJob)(jobId, { stage: 'pending-worker', progress: 35 });
+    }
+    catch (err) {
+        (0, jobQueue_1.failJob)(jobId, err.message);
+    }
+}
+async function runLodJob(jobId, fileId, projectId, options) {
+    (0, jobQueue_1.updateJob)(jobId, { status: 'processing', stage: 'resolving', progress: 10, assetId: fileId });
+    try {
+        const db = getNosqlDb();
+        if (!db)
+            throw new Error('Storage database not available');
+        const fileDoc = await db.collection('storage_files').findOne({ fileId, projectId });
+        if (!fileDoc)
+            throw new Error(`File ${fileId} not found`);
+        (0, jobQueue_1.updateJob)(jobId, { stage: 'queued-lod', progress: 25 });
+        await db.collection('media_metadata').updateOne({ assetId: fileId, projectId }, {
+            $set: {
+                assetId: fileId,
+                projectId,
+                pendingLod: {
+                    levels: options.levels ?? 3,
+                    reductionRatios: options.reductionRatios ?? [0.5, 0.25, 0.1],
+                    algorithm: options.algorithm ?? 'quadric',
+                    outputFormat: options.outputFormat ?? 'glb',
+                    requestedAt: new Date(),
+                },
+                customTags: {},
+                extractedAt: new Date(),
+            },
+        }, { upsert: true });
+        (0, jobQueue_1.updateJob)(jobId, { stage: 'pending-worker', progress: 30 });
+    }
+    catch (err) {
+        (0, jobQueue_1.failJob)(jobId, err.message);
+    }
+}
+async function resolveAssetDependencyGraph(projectId, rootAssetId, maxDepth = 5) {
+    const db = getNosqlDb();
+    if (!db)
+        return { nodes: [], edges: [] };
+    const filesCol = db.collection('storage_files');
+    const visited = new Set();
+    const nodes = [];
+    const edges = [];
+    async function walk(assetId, depth) {
+        if (depth > maxDepth || visited.has(assetId))
+            return;
+        visited.add(assetId);
+        const file = await filesCol.findOne({ fileId: assetId, projectId });
+        nodes.push({
+            assetId,
+            type: file?.contentType ?? 'unknown',
+            resolved: !!file,
+        });
+        // Dependencies are stored as a `dependencies` array on the file document
+        const deps = file?.dependencies ?? [];
+        for (const depId of deps) {
+            edges.push({ from: assetId, to: depId, relationship: 'depends-on' });
+            await walk(depId, depth + 1);
+        }
+    }
+    await walk(rootAssetId, 0);
+    await db.collection('asset_dependency_graphs').updateOne({ rootAssetId, projectId }, { $set: { rootAssetId, projectId, nodes, edges, resolvedAt: new Date() } }, { upsert: true });
+    return { nodes, edges };
+}

package/dist/types/index.d.ts

@@ -186,4 +186,192 @@ export interface Export {
     useConnections?: boolean;
     useCredentials?: boolean;
     storageDbId?: string;
+    deliverableType?: 'api' | 'video-stream' | 'game-build' | 'asset-bundle' | 'app-binary';
+    deliverableVersion?: string;
+    deliverableTargets?: DeliveryTarget[];
+    publishedAt?: Date;
+    publishedBy?: string;
+    cdnUrl?: string;
+}
+export type DistributionTarget = 'cdnPush' | 'hlsStream' | 'steam' | 'appStoreConnect' | 'googlePlay' | 'itchIo' | 'customWebhook';
+export type DeliveryStatus = 'pending' | 'publishing' | 'published' | 'failed';
+export interface DeliveryTarget {
+    connectionId: string;
+    target: DistributionTarget;
+    channel?: string;
+    publishedAt?: Date;
+    publishedBy?: string;
+    receipt?: Record<string, string>;
+    status: DeliveryStatus;
+}
+export interface DistributionConnection {
+    id: string;
+    name: string;
+    target: DistributionTarget;
+    credentialId?: string;
+    projectId: string;
+    config: Record<string, string>;
+    createdAt: Date;
+    description?: string;
+}
+export interface QcCheck {
+    name: string;
+    passed: boolean;
+    value: string | number;
+    threshold: string | number;
+    message?: string;
+}
+export interface QcReportRecord {
+    assetId: string;
+    projectId: string;
+    checks: QcCheck[];
+    overallPassed: boolean;
+    generatedAt: Date;
+}
+export type JobType = 'ingest' | 'transcode' | 'caption' | 'thumbnail' | 'render' | 'format-convert' | 'lod' | 'distribute' | 'qc' | 'transcription' | 'upscale' | 'generate-asset';
+export type AiProvider = 'openai' | 'deepgram' | 'assemblyai' | 'stabilityai' | 'meshy' | 'elevenlabs' | 'custom';
+export interface PipelineSuggestion {
+    rationale: string;
+    nodesToAdd: {
+        type: string;
+        label: string;
+        position: {
+            x: number;
+            y: number;
+        };
+    }[];
+    edgesToAdd: {
+        source: string;
+        sourceHandle: string;
+        target: string;
+        targetHandle: string;
+    }[];
+}
+export type RenderFarmProvider = 'flamenco' | 'deadline' | 'rebusfarm' | 'sheepit' | 'custom';
+export interface RenderFarmConnection {
+    id: string;
+    name: string;
+    provider: RenderFarmProvider;
+    apiUrl: string;
+    credentialId?: string;
+    projectId: string;
+    createdAt: Date;
+    description?: string;
+}
+export interface LodLevel {
+    level: number;
+    ratio: number;
+    storageFileId: string;
+    polyCount?: number;
+    fileSize?: number;
+}
+export interface LodManifestRecord {
+    assetId: string;
+    projectId: string;
+    levels: LodLevel[];
+    generatedAt: Date;
+}
+export interface AssetDependencyGraphRecord {
+    rootAssetId: string;
+    projectId: string;
+    nodes: {
+        assetId: string;
+        type: string;
+        resolved: boolean;
+    }[];
+    edges: {
+        from: string;
+        to: string;
+        relationship: string;
+    }[];
+    resolvedAt: Date;
+}
+export type ReviewStatus = 'open' | 'approved' | 'rejected' | 'expired';
+export type ReviewDecision = 'approve' | 'reject';
+export interface ReviewApproval {
+    userId: string;
+    username: string;
+    decision: ReviewDecision;
+    comment?: string;
+    at: Date;
+}
+export interface ReviewSessionRecord {
+    id: string;
+    projectId: string;
+    assetId: string;
+    assetVersionId: string;
+    status: ReviewStatus;
+    requiredApprovers: number;
+    approvals: ReviewApproval[];
+    deadline?: Date;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export type AnnotationType = 'timecoded' | 'spatial' | 'region';
+export interface AnnotationRecord {
+    id: string;
+    assetId: string;
+    assetVersionId: string;
+    projectId: string;
+    authorId: string;
+    authorUsername: string;
+    type: AnnotationType;
+    timecode?: string;
+    position3d?: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    regionRect?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    text: string;
+    resolved: boolean;
+    resolvedBy?: string;
+    createdAt: Date;
+}
+export type JobStatus = 'pending' | 'processing' | 'completed' | 'failed';
+export interface JobRecord {
+    jobId: string;
+    jobType: JobType;
+    userId: string;
+    projectId: string;
+    assetId?: string;
+    status: JobStatus;
+    stage: string;
+    progress: number;
+    payload: Record<string, any>;
+    error?: string;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export interface AssetMetadataRecord {
+    assetId: string;
+    projectId: string;
+    duration?: number;
+    width?: number;
+    height?: number;
+    frameRate?: number;
+    colorSpace?: string;
+    codec?: string;
+    bitrate?: number;
+    channels?: number;
+    sampleRate?: number;
+    customTags: Record<string, string>;
+    extractedAt: Date;
+}
+export interface AssetVersionRecord {
+    versionId: string;
+    assetId: string;
+    projectId: string;
+    version: number;
+    label?: string;
+    storageKey: string;
+    size: number;
+    createdBy: string;
+    changeNote?: string;
+    createdAt: Date;
 }

package/package.json

@@ -1,63 +1,63 @@
-{
-  "name": "streamby-core",
-  "version": "0.28.5",
-  "description": "StreamBy middleware framework for media storage management",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "files": [
-    "dist"
-  ],
-  "scripts": {
-    "build": "tsc",
-    "test": "vitest",
-    "dev": "ts-node-dev --respawn --clear dev.ts",
-    "prepublishOnly": "npm run build"
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/GwerhDev/StreamBy-Package.git"
-  },
-  "keywords": [
-    "streamby",
-    "middleware",
-    "upload",
-    "storage",
-    "s3",
-    "express",
-    "typescript"
-  ],
-  "author": "TerminalCore Labs",
-  "license": "MIT",
-  "dependencies": {
-    "@aws-sdk/client-s3": "^3.528.0",
-    "@aws-sdk/s3-request-presigner": "^3.787.0",
-    "@prisma/client": "^6.12.0",
-    "bcrypt": "^5.1.1",
-    "dotenv": "^16.5.0",
-    "express": "^4.0.0",
-    "mongodb": "^6.17.0",
-    "mongoose": "^8.13.2",
-    "node-fetch": "^3.0.0",
-    "pg": "^8.16.3",
-    "prisma": "^6.12.0",
-    "ws": "^8.20.0"
-  },
-  "devDependencies": {
-    "@types/bcrypt": "^5.0.2",
-    "@types/cors": "^2.8.18",
-    "@types/express": "^4.17.17",
-    "@types/mongodb": "^4.0.7",
-    "@types/node": "^22.15.21",
-    "@types/pg": "^8.15.4",
-    "@types/supertest": "^6.0.3",
-    "@types/ws": "^8.18.1",
-    "cors": "^2.8.5",
-    "supertest": "^7.1.4",
-    "ts-node-dev": "^2.0.0",
-    "typescript": "^5.8.3",
-    "vitest": "^3.1.1"
-  },
-  "peerDependencies": {
-    "express": "^4.0.0"
-  }
-}
+{
+  "name": "streamby-core",
+  "version": "0.28.6",
+  "description": "StreamBy middleware framework for media storage management",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest",
+    "dev": "ts-node-dev --respawn --clear dev.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/GwerhDev/StreamBy-Package.git"
+  },
+  "keywords": [
+    "streamby",
+    "middleware",
+    "upload",
+    "storage",
+    "s3",
+    "express",
+    "typescript"
+  ],
+  "author": "TerminalCore Labs",
+  "license": "MIT",
+  "dependencies": {
+    "@aws-sdk/client-s3": "^3.528.0",
+    "@aws-sdk/s3-request-presigner": "^3.787.0",
+    "@prisma/client": "^6.12.0",
+    "bcrypt": "^5.1.1",
+    "dotenv": "^16.5.0",
+    "express": "^4.0.0",
+    "mongodb": "^6.17.0",
+    "mongoose": "^8.13.2",
+    "node-fetch": "^3.0.0",
+    "pg": "^8.16.3",
+    "prisma": "^6.12.0",
+    "ws": "^8.20.0"
+  },
+  "devDependencies": {
+    "@types/bcrypt": "^5.0.2",
+    "@types/cors": "^2.8.18",
+    "@types/express": "^4.17.17",
+    "@types/mongodb": "^4.0.7",
+    "@types/node": "^22.15.21",
+    "@types/pg": "^8.15.4",
+    "@types/supertest": "^6.0.3",
+    "@types/ws": "^8.18.1",
+    "cors": "^2.8.5",
+    "supertest": "^7.1.4",
+    "ts-node-dev": "^2.0.0",
+    "typescript": "^5.8.3",
+    "vitest": "^3.1.1"
+  },
+  "peerDependencies": {
+    "express": "^4.0.0"
+  }
+}

package/dist/utils/crypto.d.ts

@@ -1,3 +0,0 @@
-export declare function encrypt(text: string, secretKey: string): string;
-export declare function decrypt(text: string, secretKey: string): string;
-export declare function hash(text: string): string;

package/dist/utils/crypto.js

@@ -1,32 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.encrypt = encrypt;
-exports.decrypt = decrypt;
-exports.hash = hash;
-const crypto_1 = __importDefault(require("crypto"));
-const ALGORITHM = 'aes-256-cbc';
-const IV_LENGTH = 16;
-function encrypt(text, secretKey) {
-    const iv = crypto_1.default.randomBytes(IV_LENGTH);
-    const key = crypto_1.default.createHash('sha256').update(String(secretKey)).digest('base64').substr(0, 32);
-    const cipher = crypto_1.default.createCipheriv(ALGORITHM, Buffer.from(key), iv);
-    let encrypted = cipher.update(text);
-    encrypted = Buffer.concat([encrypted, cipher.final()]);
-    return iv.toString('hex') + ':' + encrypted.toString('hex');
-}
-function decrypt(text, secretKey) {
-    const textParts = text.split(':');
-    const iv = Buffer.from(textParts.shift(), 'hex');
-    const encryptedText = Buffer.from(textParts.join(':'), 'hex');
-    const key = crypto_1.default.createHash('sha256').update(String(secretKey)).digest('base64').substr(0, 32);
-    const decipher = crypto_1.default.createDecipheriv(ALGORITHM, Buffer.from(key), iv);
-    let decrypted = decipher.update(encryptedText);
-    decrypted = Buffer.concat([decrypted, decipher.final()]);
-    return decrypted.toString();
-}
-function hash(text) {
-    return crypto_1.default.createHash('sha256').update(text).digest('hex');
-}