streamby-core 0.28.6 → 0.29.1

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

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

package/dist/middleware/routes/workflow.js

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.workflowRouter = workflowRouter;
+const express_1 = require("express");
+const crypto_1 = require("crypto");
+const manager_1 = require("../../models/manager");
+const auth_1 = require("../../utils/auth");
+const mongodb_1 = require("mongodb");
+function workflowRouter(config) {
+    const router = (0, express_1.Router)();
+    const Project = (0, manager_1.getModel)('projects');
+    router.get('/projects/:id/workflows', async (req, res) => {
+        try {
+            const auth = await config.authProvider(req);
+            if (!auth?.userId)
+                return res.status(401).json({ message: 'Unauthorized' });
+            const project = await Project.findOne({ _id: req.params.id });
+            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 access' });
+            res.json({ data: project.workflows ?? [], message: 'Workflows fetched successfully' });
+        }
+        catch (err) {
+            res.status(500).json({ message: 'Failed to fetch workflows', details: err.message });
+        }
+    });
+    router.get('/projects/:id/workflows/:workflow_id', async (req, res) => {
+        try {
+            const auth = await config.authProvider(req);
+            if (!auth?.userId)
+                return res.status(401).json({ message: 'Unauthorized' });
+            const project = await Project.findOne({ _id: req.params.id });
+            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 access' });
+            const workflow = (project.workflows ?? []).find((w) => w.id === req.params.workflow_id);
+            if (!workflow)
+                return res.status(404).json({ message: 'Workflow not found' });
+            res.json({ data: workflow, message: 'Workflow fetched successfully' });
+        }
+        catch (err) {
+            res.status(500).json({ message: 'Failed to fetch workflow', details: err.message });
+        }
+    });
+    router.post('/projects/:id/workflows', async (req, res) => {
+        try {
+            const auth = await config.authProvider(req);
+            if (!auth?.userId)
+                return res.status(401).json({ message: 'Unauthorized' });
+            const projectId = req.params.id;
+            const project = await Project.findOne({ _id: projectId });
+            if (!project || !(0, auth_1.isProjectMember)(project, auth.userId)) {
+                return res.status(403).json({ message: 'Unauthorized project access' });
+            }
+            const { name, description } = req.body;
+            if (!name)
+                return res.status(400).json({ message: 'Missing workflow name' });
+            const now = new Date();
+            const workflow = {
+                id: (0, crypto_1.randomUUID)(),
+                name,
+                description: description ?? '',
+                status: 'draft',
+                projectId,
+                nodeSchema: null,
+                createdAt: now,
+                updatedAt: now,
+            };
+            if (project.dbType === 'sql') {
+                const SqlProject = (0, manager_1.getModel)('projects', 'sql');
+                const currentWorkflows = project.workflows ?? [];
+                await SqlProject.update({ _id: projectId }, { workflows: [...currentWorkflows, workflow] });
+            }
+            else {
+                await Project.update({ _id: new mongodb_1.ObjectId(projectId) }, { $push: { workflows: workflow } });
+            }
+            res.status(201).json({ data: workflow, message: 'Workflow created successfully' });
+        }
+        catch (err) {
+            res.status(500).json({ message: 'Failed to create workflow', details: err.message });
+        }
+    });
+    router.patch('/projects/:id/workflows/:workflow_id', async (req, res) => {
+        try {
+            const auth = await config.authProvider(req);
+            if (!auth?.userId)
+                return res.status(401).json({ message: 'Unauthorized' });
+            const { id: projectId, workflow_id: workflowId } = req.params;
+            const project = await Project.findOne({ _id: projectId });
+            if (!project || !(0, auth_1.isProjectMember)(project, auth.userId)) {
+                return res.status(403).json({ message: 'Unauthorized project access' });
+            }
+            const existing = (project.workflows ?? []).find((w) => w.id === workflowId);
+            if (!existing)
+                return res.status(404).json({ message: 'Workflow not found' });
+            const { name, description, status, nodeSchema } = req.body;
+            const updated = {
+                ...existing,
+                name: name ?? existing.name,
+                description: description ?? existing.description,
+                status: status ?? existing.status,
+                nodeSchema: nodeSchema !== undefined ? nodeSchema : existing.nodeSchema,
+                updatedAt: new Date(),
+            };
+            if (project.dbType === 'sql') {
+                const SqlProject = (0, manager_1.getModel)('projects', 'sql');
+                const updatedWorkflows = (project.workflows ?? []).map((w) => w.id === workflowId ? updated : w);
+                await SqlProject.update({ _id: projectId }, { workflows: updatedWorkflows });
+            }
+            else {
+                await Project.update({ _id: new mongodb_1.ObjectId(projectId), 'workflows.id': workflowId }, {
+                    $set: {
+                        'workflows.$.name': updated.name,
+                        'workflows.$.description': updated.description,
+                        'workflows.$.status': updated.status,
+                        'workflows.$.nodeSchema': updated.nodeSchema,
+                        'workflows.$.updatedAt': updated.updatedAt,
+                    },
+                });
+            }
+            res.json({ data: updated, message: 'Workflow updated successfully' });
+        }
+        catch (err) {
+            res.status(500).json({ message: 'Failed to update workflow', details: err.message });
+        }
+    });
+    router.delete('/projects/:id/workflows/:workflow_id', async (req, res) => {
+        try {
+            const auth = await config.authProvider(req);
+            if (!auth?.userId)
+                return res.status(401).json({ message: 'Unauthorized' });
+            const { id: projectId, workflow_id: workflowId } = req.params;
+            const project = await Project.findOne({ _id: projectId });
+            if (!project || !(0, auth_1.isProjectMember)(project, auth.userId)) {
+                return res.status(403).json({ message: 'Unauthorized project access' });
+            }
+            const existing = (project.workflows ?? []).find((w) => w.id === workflowId);
+            if (!existing)
+                return res.status(404).json({ message: 'Workflow not found' });
+            if (project.dbType === 'sql') {
+                const SqlProject = (0, manager_1.getModel)('projects', 'sql');
+                const updatedWorkflows = (project.workflows ?? []).filter((w) => w.id !== workflowId);
+                await SqlProject.update({ _id: projectId }, { workflows: updatedWorkflows });
+            }
+            else {
+                await Project.update({ _id: new mongodb_1.ObjectId(projectId) }, { $pull: { workflows: { id: workflowId } } });
+            }
+            res.json({ message: 'Workflow deleted successfully' });
+        }
+        catch (err) {
+            res.status(500).json({ message: 'Failed to delete workflow', details: 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/utils/crypto.d.ts

@@ -0,0 +1,3 @@
+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

@@ -0,0 +1,32 @@
+"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');
+}

package/package.json

@@ -1,63 +1,63 @@
-{
-  "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"
-  }
-}
+{
+  "name": "streamby-core",
+  "version": "0.29.1",
+  "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"
+  }
+}