streamby-core 0.29.6 → 0.29.8

package/README.md

@@ -1,283 +1,283 @@
-# @streamby/core
-
-Middleware framework for building storage-agnostic media APIs.  
-Part of the [StreamBy](https://streamby.nhexa.cl) ecosystem by TerminalCore Labs.
-
----
-
-## 🚀 What is it?
-
-`@streamby/core` is a plug-and-play middleware for Express (or compatible frameworks) that enables file uploads, listings and **multi-project access** over services like:
-
-- ✅ AWS S3
-- ✅ Google Cloud Storage (soon)
-- ✅ Cloudflare R2 (soon)
-- ✅ Local/Personal servers (soon)
-
-It's designed to be installed inside your existing API as a library — **no need to run a separate backend**.
-
----
-
-## 📦 Installation
-
-```bash
-npm install @streamby/core ws
-npm install -D @types/ws
-```
-
----
-
-## 🧱 Basic usage
-
-```ts
-import http from 'http';
-import express from 'express';
-import { WebSocketServer } from 'ws';
-import { createStreamByRouter } from '@streamby/core';
-
-const app = express();
-const server = http.createServer(app);
-const wss = new WebSocketServer({ server, path: '/streamby/ws' });
-
-app.use('/streamby', express.json(), createStreamByRouter({
-  authProvider: async (req) => {
-    // validate token/session and return user info
-    return { userId: 'user-id', username: 'username', role: 'admin' };
-  },
-  databases: [
-    { id: 'mongo', type: 'nosql', connectionString: process.env.MONGO_URI! },
-    { id: 'postgres', type: 'sql', connectionString: process.env.POSTGRES_URI!, main: true },
-  ],
-  storageProviders: [
-    {
-      type: 's3',
-      config: {
-        bucket: process.env.AWS_BUCKET!,
-        region: process.env.AWS_REGION!,
-        accessKeyId: process.env.AWS_ACCESS_KEY!,
-        secretAccessKey: process.env.AWS_SECRET_KEY!,
-      },
-    },
-  ],
-  encrypt: process.env.STREAMBY_ENCRYPTION_KEY,
-  websocket: { server: wss },
-}));
-
-server.listen(3000);
-```
-
-> **Important:** use `http.createServer(app)` and pass `server.listen()` instead of `app.listen()`.  
-> This is required so the `WebSocketServer` shares the same port as the HTTP server.
-
----
-
-## 🗄️ Database Schema Setup
-
-`@streamby/core` requires a pre-configured database schema for its internal operations. It does not manage database connections directly; instead, it expects the host application to provide initialized connection instances. This ensures full control and flexibility for the host environment.
-
-The library will only interact with the specified schema and will not touch other schemas in your database. The `reset` option is opt-in and will only drop and recreate the specified `streamby` schema if explicitly set to `true`.
-
-### PostgreSQL Example
-
-```ts
-import { Pool } from "pg";
-import { setupStreambyPg } from "@streamby/core/pg/setup"; // Adjust path as per your package structure
-
-const pool = new Pool({ connectionString: process.env.DATABASE_URL });
-
-// Call setupStreambyPg to ensure the schema and tables are created
-// reset: false (default) ensures idempotency and no data loss
-await setupStreambyPg({ pool, schema: "streamby", reset: false });
-```
-
-### MongoDB Example
-
-```ts
-import { MongoClient } from "mongodb";
-import { setupStreambyMongo } from "@streamby/core/mongo/setup"; // Adjust path as per your package structure
-
-const client = new MongoClient(process.env.MONGO_URL!);
-
-// Connect the MongoDB client
-await client.connect();
-
-// Call setupStreambyMongo to ensure collections and indexes are created
-await setupStreambyMongo({ client, dbName: "streamby" });
-```
-
-```ts
-import express from 'express';
-import { createStreamByRouter } from '@streamby/core';
-
-const app = express();
-
-app.use('/streamby', createStreamByRouter({
-  storageProvider: {
-    type: 's3',
-    config: {
-      bucket: 'your-bucket-name',
-      region: 'your-region',
-      accessKeyId: 'YOUR_AWS_KEY',
-      secretAccessKey: 'YOUR_AWS_SECRET'
-    }
-  },
-  authProvider: async (req) => {
-    // extract token/cookie and validate
-    return {
-      userId: 'demo',
-      projects: ['demo-project'],
-      role: 'admin',
-    };
-  },
-  projectProvider: async (projectId) => {
-    // fetch project from your DB
-    return {
-      id: projectId,
-      name: 'Demo Project',
-      description: 'Demo for StreamBy integration',
-      rootFolders: [],
-      settings: { allowUpload: true }
-    };
-  }
-}));
-
-app.listen(3000);
-```
-
----
-
-## 🧪 Testing
-
-```bash
-npm run test
-```
-
-Unit tests use [Vitest](https://vitest.dev) and [Supertest](https://www.npmjs.com/package/supertest).
-
----
-
-## 📁 Features
-
-- 📂 Multi-project access control
-- 🔐 Project-aware file uploads & listings
-- 🧹 Modular adapters per storage provider
-- 🧰 Built-in testability with mock auth & storage
-- ✨ Simple to extend for custom business logic
-
----
-
-## 🗺️ API Endpoints
-
-Here's a summary of the key API endpoints provided by `@streamby/core`:
-
-### `GET /streamby/projects`
-
-Lists all projects accessible by the authenticated user.
-
-**Query Parameters:**
-- `archived`: (Optional) Filter projects by their archived status.
-  - `true`: Returns only archived projects.
-  - `false`: Returns only unarchived projects.
-  - (Omitted): Returns all projects (both archived and unarchived).
-
-**Example Response:**
-```json
-{
-  "projects": [
-    {
-      "id": "project1_id",
-      "dbType": "nosql",
-      "name": "My NoSQL Project",
-      "image": "url_to_image",
-      "archived": false
-    },
-    {
-      "id": "project2_id",
-      "dbType": "sql",
-      "name": "My SQL Project",
-      "image": "url_to_image",
-      "archived": true
-    }
-  ]
-}
-```
-
-### `PATCH /streamby/projects/:id/archive`
-
-Archives a specific project. After archiving, it returns the complete list of projects for the user, including the updated project.
-
-**Example Response:**
-```json
-{
-  "success": true,
-  "projects": [
-    {
-      "id": "project1_id",
-      "dbType": "nosql",
-      "name": "My NoSQL Project",
-      "image": "url_to_image",
-      "archived": true
-    },
-    {
-      "id": "project2_id",
-      "dbType": "sql",
-      "name": "My SQL Project",
-      "image": "url_to_image",
-      "archived": false
-    }
-  ]
-}
-```
-
-### `PATCH /streamby/projects/:id/unarchive`
-
-Unarchives a specific project. After unarchiving, it returns the complete list of projects for the user, including the updated project.
-
-**Example Response:**
-```json
-{
-  "success": true,
-  "projects": [
-    {
-      "id": "project1_id",
-      "dbType": "nosql",
-      "name": "My NoSQL Project",
-      "image": "url_to_image",
-      "archived": false
-    },
-    {
-      "id": "project2_id",
-      "dbType": "sql",
-      "name": "My SQL Project",
-      "image": "url_to_image",
-      "archived": false
-    }
-  ]
-}
-```
-
----
-
-## 🚣 Roadmap
-
-- [ ] Support for Google Cloud Storage
-- [ ] CLI tool for uploading files
-- [ ] Role-based access control middleware
-- [ ] Plugin system for extended routes
-- [ ] Streaming support (HLS, audio, etc.)
-
----
-
-## 🧑‍💻 Maintained by
-
-**TerminalCore Labs** – part of [Nhexa Entertainment](https://nhexa.cl)  
-Developed as open-source infrastructure for creative and media-oriented apps.
-
-Visit us [here](https://terminalcore.cl)
-
----
-
-## 📟 License
-
-[MIT](./LICENSE)
-
+# @streamby/core
+
+Middleware framework for building storage-agnostic media APIs.  
+Part of the [StreamBy](https://streamby.nhexa.cl) ecosystem by TerminalCore Labs.
+
+---
+
+## 🚀 What is it?
+
+`@streamby/core` is a plug-and-play middleware for Express (or compatible frameworks) that enables file uploads, listings and **multi-project access** over services like:
+
+- ✅ AWS S3
+- ✅ Google Cloud Storage (soon)
+- ✅ Cloudflare R2 (soon)
+- ✅ Local/Personal servers (soon)
+
+It's designed to be installed inside your existing API as a library — **no need to run a separate backend**.
+
+---
+
+## 📦 Installation
+
+```bash
+npm install @streamby/core ws
+npm install -D @types/ws
+```
+
+---
+
+## 🧱 Basic usage
+
+```ts
+import http from 'http';
+import express from 'express';
+import { WebSocketServer } from 'ws';
+import { createStreamByRouter } from '@streamby/core';
+
+const app = express();
+const server = http.createServer(app);
+const wss = new WebSocketServer({ server, path: '/streamby/ws' });
+
+app.use('/streamby', express.json(), createStreamByRouter({
+  authProvider: async (req) => {
+    // validate token/session and return user info
+    return { userId: 'user-id', username: 'username', role: 'admin' };
+  },
+  databases: [
+    { id: 'mongo', type: 'nosql', connectionString: process.env.MONGO_URI! },
+    { id: 'postgres', type: 'sql', connectionString: process.env.POSTGRES_URI!, main: true },
+  ],
+  storageProviders: [
+    {
+      type: 's3',
+      config: {
+        bucket: process.env.AWS_BUCKET!,
+        region: process.env.AWS_REGION!,
+        accessKeyId: process.env.AWS_ACCESS_KEY!,
+        secretAccessKey: process.env.AWS_SECRET_KEY!,
+      },
+    },
+  ],
+  encrypt: process.env.STREAMBY_ENCRYPTION_KEY,
+  websocket: { server: wss },
+}));
+
+server.listen(3000);
+```
+
+> **Important:** use `http.createServer(app)` and pass `server.listen()` instead of `app.listen()`.  
+> This is required so the `WebSocketServer` shares the same port as the HTTP server.
+
+---
+
+## 🗄️ Database Schema Setup
+
+`@streamby/core` requires a pre-configured database schema for its internal operations. It does not manage database connections directly; instead, it expects the host application to provide initialized connection instances. This ensures full control and flexibility for the host environment.
+
+The library will only interact with the specified schema and will not touch other schemas in your database. The `reset` option is opt-in and will only drop and recreate the specified `streamby` schema if explicitly set to `true`.
+
+### PostgreSQL Example
+
+```ts
+import { Pool } from "pg";
+import { setupStreambyPg } from "@streamby/core/pg/setup"; // Adjust path as per your package structure
+
+const pool = new Pool({ connectionString: process.env.DATABASE_URL });
+
+// Call setupStreambyPg to ensure the schema and tables are created
+// reset: false (default) ensures idempotency and no data loss
+await setupStreambyPg({ pool, schema: "streamby", reset: false });
+```
+
+### MongoDB Example
+
+```ts
+import { MongoClient } from "mongodb";
+import { setupStreambyMongo } from "@streamby/core/mongo/setup"; // Adjust path as per your package structure
+
+const client = new MongoClient(process.env.MONGO_URL!);
+
+// Connect the MongoDB client
+await client.connect();
+
+// Call setupStreambyMongo to ensure collections and indexes are created
+await setupStreambyMongo({ client, dbName: "streamby" });
+```
+
+```ts
+import express from 'express';
+import { createStreamByRouter } from '@streamby/core';
+
+const app = express();
+
+app.use('/streamby', createStreamByRouter({
+  storageProvider: {
+    type: 's3',
+    config: {
+      bucket: 'your-bucket-name',
+      region: 'your-region',
+      accessKeyId: 'YOUR_AWS_KEY',
+      secretAccessKey: 'YOUR_AWS_SECRET'
+    }
+  },
+  authProvider: async (req) => {
+    // extract token/cookie and validate
+    return {
+      userId: 'demo',
+      projects: ['demo-project'],
+      role: 'admin',
+    };
+  },
+  projectProvider: async (projectId) => {
+    // fetch project from your DB
+    return {
+      id: projectId,
+      name: 'Demo Project',
+      description: 'Demo for StreamBy integration',
+      rootFolders: [],
+      settings: { allowUpload: true }
+    };
+  }
+}));
+
+app.listen(3000);
+```
+
+---
+
+## 🧪 Testing
+
+```bash
+npm run test
+```
+
+Unit tests use [Vitest](https://vitest.dev) and [Supertest](https://www.npmjs.com/package/supertest).
+
+---
+
+## 📁 Features
+
+- 📂 Multi-project access control
+- 🔐 Project-aware file uploads & listings
+- 🧹 Modular adapters per storage provider
+- 🧰 Built-in testability with mock auth & storage
+- ✨ Simple to extend for custom business logic
+
+---
+
+## 🗺️ API Endpoints
+
+Here's a summary of the key API endpoints provided by `@streamby/core`:
+
+### `GET /streamby/projects`
+
+Lists all projects accessible by the authenticated user.
+
+**Query Parameters:**
+- `archived`: (Optional) Filter projects by their archived status.
+  - `true`: Returns only archived projects.
+  - `false`: Returns only unarchived projects.
+  - (Omitted): Returns all projects (both archived and unarchived).
+
+**Example Response:**
+```json
+{
+  "projects": [
+    {
+      "id": "project1_id",
+      "dbType": "nosql",
+      "name": "My NoSQL Project",
+      "image": "url_to_image",
+      "archived": false
+    },
+    {
+      "id": "project2_id",
+      "dbType": "sql",
+      "name": "My SQL Project",
+      "image": "url_to_image",
+      "archived": true
+    }
+  ]
+}
+```
+
+### `PATCH /streamby/projects/:id/archive`
+
+Archives a specific project. After archiving, it returns the complete list of projects for the user, including the updated project.
+
+**Example Response:**
+```json
+{
+  "success": true,
+  "projects": [
+    {
+      "id": "project1_id",
+      "dbType": "nosql",
+      "name": "My NoSQL Project",
+      "image": "url_to_image",
+      "archived": true
+    },
+    {
+      "id": "project2_id",
+      "dbType": "sql",
+      "name": "My SQL Project",
+      "image": "url_to_image",
+      "archived": false
+    }
+  ]
+}
+```
+
+### `PATCH /streamby/projects/:id/unarchive`
+
+Unarchives a specific project. After unarchiving, it returns the complete list of projects for the user, including the updated project.
+
+**Example Response:**
+```json
+{
+  "success": true,
+  "projects": [
+    {
+      "id": "project1_id",
+      "dbType": "nosql",
+      "name": "My NoSQL Project",
+      "image": "url_to_image",
+      "archived": false
+    },
+    {
+      "id": "project2_id",
+      "dbType": "sql",
+      "name": "My SQL Project",
+      "image": "url_to_image",
+      "archived": false
+    }
+  ]
+}
+```
+
+---
+
+## 🚣 Roadmap
+
+- [ ] Support for Google Cloud Storage
+- [ ] CLI tool for uploading files
+- [ ] Role-based access control middleware
+- [ ] Plugin system for extended routes
+- [ ] Streaming support (HLS, audio, etc.)
+
+---
+
+## 🧑‍💻 Maintained by
+
+**TerminalCore Labs** – part of [Nhexa Entertainment](https://nhexa.cl)  
+Developed as open-source infrastructure for creative and media-oriented apps.
+
+Visit us [here](https://terminalcore.cl)
+
+---
+
+## 📟 License
+
+[MIT](./LICENSE)
+

package/dist/adapters/database/connectionManager.js

@@ -43,85 +43,85 @@ 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 '[]';
-      ALTER TABLE streamby.projects ADD COLUMN IF NOT EXISTS workflow         JSONB;
-      ALTER TABLE streamby.projects ADD COLUMN IF NOT EXISTS pipelines        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 '[]';
+      ALTER TABLE streamby.projects ADD COLUMN IF NOT EXISTS workflow         JSONB;
+      ALTER TABLE streamby.projects ADD COLUMN IF NOT EXISTS pipelines        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

@@ -32,6 +32,7 @@ const ai_1 = require("./routes/ai");
 const production_1 = require("./routes/production");
 const rights_1 = require("./routes/rights");
 const workflow_1 = require("./routes/workflow");
+const pipeline_1 = require("./routes/pipeline");
 function createStreamByRouter(config) {
     const router = express_1.default.Router();
     if (config.encrypt)
@@ -104,5 +105,6 @@ function createStreamByRouter(config) {
     router.use((0, production_1.productionRouter)(config));
     router.use((0, rights_1.rightsRouter)(config));
     router.use((0, workflow_1.workflowRouter)(config));
+    router.use((0, pipeline_1.pipelineRouter)(config));
     return router;
 }

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

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

package/dist/middleware/routes/pipeline.js

@@ -0,0 +1,171 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pipelineRouter = pipelineRouter;
+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();
+}
+// A Pipeline is a sub-workflow scoped to a project. The `pipelines` collection is the
+// source of truth (holds the full nodeSchema); ProjectInfo.pipelines mirrors lightweight
+// refs so the sidebar can list them without loading every schema.
+function pipelineRouter(_config) {
+    const router = (0, express_1.Router)();
+    const Project = (0, manager_1.getModel)('projects');
+    const toRef = (p) => ({ id: p.id, name: p.name, order: p.order });
+    // Rewrite ProjectInfo.pipelines from the current collection state, sorted by order.
+    const syncProjectRefs = async (projectId) => {
+        const db = getDb();
+        if (!db)
+            return;
+        const all = await db.collection('pipelines')
+            .find({ projectId })
+            .project({ _id: 0, id: 1, name: 1, order: 1 })
+            .sort({ order: 1, createdAt: 1 })
+            .toArray();
+        const refs = all.map(p => toRef(p));
+        await Project.update({ _id: projectId }, { pipelines: refs });
+    };
+    router.get('/projects/:projectId/pipelines', 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 pipelines = await db.collection('pipelines')
+                .find({ projectId })
+                .sort({ order: 1, createdAt: 1 })
+                .toArray();
+            res.json({ pipelines });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    router.post('/projects/:projectId/pipelines', 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 pipeline = {
+                id: crypto_1.default.randomUUID(),
+                projectId,
+                name,
+                description: description ?? null,
+                order: order ?? (project.pipelines?.length ?? 0),
+                nodeSchema: null,
+                createdBy: auth.userId,
+                createdAt: now,
+                updatedAt: now,
+            };
+            await db.collection('pipelines').insertOne({ ...pipeline });
+            await syncProjectRefs(projectId);
+            res.status(201).json({ pipeline });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    router.get('/projects/:projectId/pipelines/:pipelineId', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId, pipelineId } = 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 pipeline = await db.collection('pipelines').findOne({ id: pipelineId, projectId });
+            if (!pipeline)
+                return res.status(404).json({ message: 'Pipeline not found' });
+            res.json({ pipeline });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    router.patch('/projects/:projectId/pipelines/:pipelineId', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId, pipelineId } = 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, nodeSchema, order } = req.body;
+            const $set = { updatedAt: new Date() };
+            if (name !== undefined)
+                $set.name = name;
+            if (description !== undefined)
+                $set.description = description;
+            if (nodeSchema !== undefined)
+                $set.nodeSchema = nodeSchema;
+            if (order !== undefined)
+                $set.order = order;
+            const result = await db.collection('pipelines').findOneAndUpdate({ id: pipelineId, projectId }, { $set }, { returnDocument: 'after' });
+            if (!result)
+                return res.status(404).json({ message: 'Pipeline not found' });
+            // Only name/order affect the lightweight refs.
+            if (name !== undefined || order !== undefined)
+                await syncProjectRefs(projectId);
+            res.json({ pipeline: result });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    router.delete('/projects/:projectId/pipelines/:pipelineId', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId, pipelineId } = 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('pipelines').deleteOne({ id: pipelineId, projectId });
+            await syncProjectRefs(projectId);
+            res.json({ message: 'Pipeline deleted' });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    return router;
+}

package/dist/middleware/routes/workflow.js

@@ -9,11 +9,9 @@ const mongodb_1 = require("mongodb");
 function workflowRouter(config) {
     const router = (0, express_1.Router)();
     const Project = (0, manager_1.getModel)('projects');
-    // A project has exactly one Workflow (the central canvas). It is stored as the
-    // single `project.workflow` object. Reads fall back to the legacy `workflows[0]`
-    // array so pre-migration data keeps working; PATCH upserts and writes only the
-    // new single field (and clears the legacy array on Mongo).
-    const resolveWorkflow = (project) => project.workflow ?? (project.workflows ?? [])[0] ?? null;
+    // A project has exactly one Workflow (the central canvas), stored as the single
+    // `project.workflow` object. PATCH upserts it.
+    const resolveWorkflow = (project) => project.workflow ?? null;
     router.get('/projects/:id/workflow', async (req, res) => {
         try {
             const auth = await config.authProvider(req);
@@ -70,7 +68,7 @@ function workflowRouter(config) {
                 await SqlProject.update({ _id: projectId }, { workflow: updated });
             }
             else {
-                await Project.update({ _id: new mongodb_1.ObjectId(projectId) }, { $set: { workflow: updated }, $unset: { workflows: '' } });
+                await Project.update({ _id: new mongodb_1.ObjectId(projectId) }, { $set: { workflow: updated } });
             }
             res.json({ data: updated, message: 'Workflow updated successfully' });
         }

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

@@ -73,6 +73,7 @@ export interface ProjectInfo {
     apiConnections?: ApiConnection[];
     dbConnections?: DbConnection[];
     storageConnections?: StorageConnection[];
+    pipelines?: PipelineRef[];
 }
 export interface Credential {
     id: string;
@@ -168,6 +169,23 @@ export interface NodeSchema {
     nodes: any[];
     edges: any[];
 }
+export interface Pipeline {
+    _id?: string;
+    id: string;
+    projectId: string;
+    name: string;
+    description?: string | null;
+    order: number;
+    nodeSchema: NodeSchema | null;
+    createdBy: string;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export interface PipelineRef {
+    id: string;
+    name: string;
+    order: number;
+}
 export interface Export {
     _id?: string;
     id: string;

package/package.json

@@ -1,63 +1,63 @@
-{
-  "name": "streamby-core",
-  "version": "0.29.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.8",
+  "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');
-}