streamby-core 0.17.0 → 0.19.0

package/README.md

@@ -1,114 +1,206 @@
-# @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
-```
-
----
-
-## 🧱 Basic usage
-
-```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
-
----
-
-## 🚣 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
+```
+
+---
+
+## 🧱 Basic usage
+
+```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.d.ts

@@ -0,0 +1,6 @@
+import { Pool } from 'pg';
+import { MongoClient } from 'mongodb';
+import { DatabaseCredential } from '../../types';
+export declare const initConnections: (configs: DatabaseCredential[]) => Promise<void>;
+export declare const getConnection: (id: string) => Pool | MongoClient;
+export declare const getConnectedIds: () => string[];

package/dist/adapters/database/connectionManager.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getConnectedIds = exports.getConnection = exports.initConnections = void 0;
+const pg_1 = require("pg");
+const mongodb_1 = require("mongodb");
+const clients = {};
+const connectedIds = [];
+const initConnections = async (configs) => {
+    for (const config of configs) {
+        if (!config.connectionString) {
+            console.error(`❌ Connection string not provided for database config with ID: ${config.id}. Skipping connection.`);
+            continue;
+        }
+        try {
+            if (config.type === 'sql') {
+                const pool = new pg_1.Pool({ connectionString: config.connectionString });
+                await pool.connect();
+                clients[config.id] = pool;
+                connectedIds.push(config.id);
+                console.log(`🟢 PostgreSQL connection established for ID: ${config.id}`);
+            }
+            else if (config.type === 'nosql') {
+                const client = new mongodb_1.MongoClient(config.connectionString);
+                await client.connect();
+                clients[config.id] = client;
+                connectedIds.push(config.id);
+                console.log(`🟢 MongoDB connection established for ID: ${config.id}`);
+            }
+        }
+        catch (error) {
+            console.error(`❌ Failed to establish ${config.type} connection for ID: ${config.id}. Error:`, error);
+        }
+    }
+};
+exports.initConnections = initConnections;
+const getConnection = (id) => {
+    const client = clients[id];
+    if (!client) {
+        throw new Error(`Connection with id ${id} not found.`);
+    }
+    return client;
+};
+exports.getConnection = getConnection;
+const getConnectedIds = () => {
+    return connectedIds;
+};
+exports.getConnectedIds = getConnectedIds;

package/dist/adapters/database/nosql.d.ts

@@ -0,0 +1,8 @@
+import { MongoClient, Document } from 'mongodb';
+export declare const nosqlAdapter: {
+    find: (connection: MongoClient, tableName: string, filter: any) => Promise<Document[]>;
+    findOne: (connection: MongoClient, tableName: string, filter: any) => Promise<Document | null>;
+    create: <T extends Document>(connection: MongoClient, tableName: string, data: T) => Promise<T>;
+    update: (connection: MongoClient, tableName: string, filter: any, data: Partial<Document>) => Promise<Document | null>;
+    delete: (connection: MongoClient, tableName: string, filter: any) => Promise<number>;
+};

package/dist/adapters/database/nosql.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nosqlAdapter = void 0;
+const mongodb_1 = require("mongodb");
+exports.nosqlAdapter = {
+    find: async (connection, tableName, filter) => {
+        const db = connection.db();
+        const result = await db.collection(tableName).find(filter).toArray();
+        return result;
+    },
+    findOne: async (connection, tableName, filter) => {
+        const db = connection.db();
+        let processedFilter = { ...filter };
+        if (processedFilter._id && typeof processedFilter._id === 'string') {
+            processedFilter._id = new mongodb_1.ObjectId(processedFilter._id);
+        }
+        const result = await db.collection(tableName).findOne(processedFilter);
+        return result;
+    },
+    create: async (connection, tableName, data) => {
+        const db = connection.db();
+        const result = await db.collection(tableName).insertOne(data);
+        return { ...data, _id: result.insertedId };
+    },
+    update: async (connection, tableName, filter, data) => {
+        const db = connection.db();
+        let processedFilter = { ...filter };
+        if (processedFilter._id && typeof processedFilter._id === 'string') {
+            processedFilter._id = new mongodb_1.ObjectId(processedFilter._id);
+        }
+        const result = await db.collection(tableName).findOneAndUpdate(processedFilter, { $set: data }, { returnDocument: 'after' });
+        if (!result) {
+            return null;
+        }
+        return result;
+    },
+    delete: async (connection, tableName, filter) => {
+        const db = connection.db();
+        let processedFilter = { ...filter };
+        if (processedFilter._id && typeof processedFilter._id === 'string') {
+            processedFilter._id = new mongodb_1.ObjectId(processedFilter._id);
+        }
+        const result = await db.collection(tableName).deleteMany(processedFilter);
+        return result.deletedCount;
+    },
+};

package/dist/adapters/database/nosqlAdapter.d.ts

@@ -0,0 +1,8 @@
+import { MongoClient, Document } from 'mongodb';
+export declare const nosqlAdapter: {
+    find: <T extends Document>(connection: MongoClient, tableName: string, filter: any) => Promise<T[]>;
+    findOne: <T extends Document>(connection: MongoClient, tableName: string, filter: any) => Promise<T | null>;
+    create: <T extends Document>(connection: MongoClient, tableName: string, data: T) => Promise<T>;
+    update: <T extends Document>(connection: MongoClient, tableName: string, filter: any, data: Partial<T>) => Promise<number>;
+    delete: <T extends Document>(connection: MongoClient, tableName: string, filter: any) => Promise<number>;
+};

package/dist/adapters/database/nosqlAdapter.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nosqlAdapter = void 0;
+exports.nosqlAdapter = {
+    find: async (connection, tableName, filter) => {
+        const db = connection.db();
+        const result = await db.collection(tableName).find(filter).toArray();
+        return result;
+    },
+    findOne: async (connection, tableName, filter) => {
+        const db = connection.db();
+        const result = await db.collection(tableName).findOne(filter);
+        return result;
+    },
+    create: async (connection, tableName, data) => {
+        const db = connection.db();
+        const result = await db.collection(tableName).insertOne(data);
+        return { ...data, _id: result.insertedId };
+    },
+    update: async (connection, tableName, filter, data) => {
+        const db = connection.db();
+        const result = await db.collection(tableName).updateMany(filter, { $set: data });
+        return result.modifiedCount;
+    },
+    delete: async (connection, tableName, filter) => {
+        const db = connection.db();
+        const result = await db.collection(tableName).deleteMany(filter);
+        return result.deletedCount;
+    },
+};

package/dist/adapters/database/sql.d.ts

@@ -0,0 +1,8 @@
+import { Pool } from 'pg';
+export declare const sqlAdapter: {
+    find: (connection: Pool, tableName: string, filter: any) => Promise<any[]>;
+    findOne: (connection: Pool, tableName: string, filter: any) => Promise<any | null>;
+    create: (connection: Pool, tableName: string, data: any) => Promise<any>;
+    update: (connection: Pool, tableName: string, filter: any, data: any) => Promise<any | null>;
+    delete: (connection: Pool, tableName: string, filter: any) => Promise<number>;
+};

package/dist/adapters/database/sql.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sqlAdapter = void 0;
+exports.sqlAdapter = {
+    find: async (connection, tableName, filter) => {
+        const keys = Object.keys(filter);
+        const values = Object.values(filter);
+        const where = keys.map((key, i) => `"${key}" = $${i + 1}`).join(' AND ');
+        const result = await connection.query(`SELECT * FROM "${tableName}" WHERE ${where}`, values);
+        return result.rows;
+    },
+    findOne: async (connection, tableName, filter) => {
+        const keys = Object.keys(filter);
+        const values = Object.values(filter);
+        const where = keys.map((key, i) => `"${key}" = $${i + 1}`).join(' AND ');
+        const result = await connection.query(`SELECT * FROM "${tableName}" WHERE ${where} LIMIT 1`, values);
+        return result.rows[0] || null;
+    },
+    create: async (connection, tableName, data) => {
+        const keys = Object.keys(data).join(', ');
+        const values = Object.values(data);
+        const placeholders = values.map((_, i) => `$${i + 1}`).join(', ');
+        const result = await connection.query(`INSERT INTO "${tableName}" (${keys}) VALUES (${placeholders}) RETURNING *`, values);
+        return result.rows[0];
+    },
+    update: async (connection, tableName, filter, data) => {
+        const dataKeys = Object.keys(data);
+        const filterKeys = Object.keys(filter);
+        const values = [...Object.values(data), ...Object.values(filter)];
+        const setClause = dataKeys.map((key, i) => `"${key}" = $${i + 1}`).join(', ');
+        const whereClause = filterKeys.map((key, i) => `"${key}" = $${dataKeys.length + i + 1}`).join(' AND ');
+        const result = await connection.query(`UPDATE "${tableName}" SET ${setClause} WHERE ${whereClause} RETURNING *`, values);
+        return result.rows[0] || null;
+    },
+    delete: async (connection, tableName, filter) => {
+        const keys = Object.keys(filter);
+        const values = Object.values(filter);
+        const where = keys.map((key, i) => `"${key}" = $${i + 1}`).join(' AND ');
+        const result = await connection.query(`DELETE FROM "${tableName}" WHERE ${where}`, values);
+        return result.rowCount || 0;
+    },
+};

package/dist/adapters/database/sqlAdapter.d.ts

@@ -0,0 +1,8 @@
+import { Pool } from 'pg';
+export declare const sqlAdapter: {
+    find: <T>(connection: Pool, tableName: string, filter: any) => Promise<T[]>;
+    findOne: <T>(connection: Pool, tableName: string, filter: any) => Promise<T | null>;
+    create: <T>(connection: Pool, tableName: string, data: T) => Promise<T>;
+    update: <T>(connection: Pool, tableName: string, filter: any, data: Partial<T>) => Promise<number>;
+    delete: (connection: Pool, tableName: string, filter: any) => Promise<number>;
+};

package/dist/adapters/database/sqlAdapter.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sqlAdapter = void 0;
+exports.sqlAdapter = {
+    find: async (connection, tableName, filter) => {
+        const keys = Object.keys(filter);
+        const values = Object.values(filter);
+        const where = keys.map((key, i) => `"${key}" = $${i + 1}`).join(' AND ');
+        const result = await connection.query(`SELECT * FROM "${tableName}" WHERE ${where}`, values);
+        return result.rows;
+    },
+    findOne: async (connection, tableName, filter) => {
+        const keys = Object.keys(filter);
+        const values = Object.values(filter);
+        const where = keys.map((key, i) => `"${key}" = $${i + 1}`).join(' AND ');
+        const result = await connection.query(`SELECT * FROM "${tableName}" WHERE ${where} LIMIT 1`, values);
+        return result.rows[0] || null;
+    },
+    create: async (connection, tableName, data) => {
+        const keys = Object.keys(data).join(', ');
+        const values = Object.values(data);
+        const placeholders = values.map((_, i) => `$${i + 1}`).join(', ');
+        const result = await connection.query(`INSERT INTO "${tableName}" (${keys}) VALUES (${placeholders}) RETURNING *`, values);
+        return result.rows[0];
+    },
+    update: async (connection, tableName, filter, data) => {
+        const dataKeys = Object.keys(data);
+        const filterKeys = Object.keys(filter);
+        const values = [...Object.values(data), ...Object.values(filter)];
+        const setClause = dataKeys.map((key, i) => `"${key}" = $${i + 1}`).join(', ');
+        const whereClause = filterKeys.map((key, i) => `"${key}" = $${dataKeys.length + i + 1}`).join(' AND ');
+        const result = await connection.query(`UPDATE "${tableName}" SET ${setClause} WHERE ${whereClause}`, values);
+        return result.rowCount || 0;
+    },
+    delete: async (connection, tableName, filter) => {
+        const keys = Object.keys(filter);
+        const values = Object.values(filter);
+        const where = keys.map((key, i) => `"${key}" = $${i + 1}`).join(' AND ');
+        const result = await connection.query(`DELETE FROM "${tableName}" WHERE ${where}`, values);
+        return result.rowCount || 0;
+    },
+};

package/dist/adapters/s3.d.ts

@@ -1,2 +1,11 @@
-import { StorageAdapter, S3Config } from '../types';
-export declare function createS3Adapter(config: S3Config): StorageAdapter;
+import { S3Config, StorageAdapter } from '../types';
+export declare class S3Adapter implements StorageAdapter {
+    private s3;
+    private bucket;
+    constructor(config: S3Config);
+    listFiles(projectId: string): Promise<any[]>;
+    deleteProjectImage(projectId: string): Promise<any>;
+    deleteProjectDirectory(projectId: string): Promise<any>;
+    getPresignedUrl(contentType: string, projectId: string): Promise<any>;
+    getPresignedProjectImageUrl(projectId: string): Promise<any>;
+}