streamby-core 0.24.16 → 0.25.0

package/README.md

@@ -1,242 +1,242 @@
-# @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
-
----
-
-## 🗄️ 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
+```
+
+---
+
+## 🧱 Basic usage
+
+---
+
+## 🗄️ 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,56 +43,56 @@ 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";
-      CREATE TABLE IF NOT EXISTS streamby.projects (
-        id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
-        name VARCHAR(255) NOT NULL,
-        description TEXT,
-        image TEXT,
-        "createdAt" TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
-        "updatedAt" TIMESTAMP WITH TIME ZONE DEFAULT NOW()
-      );
+        await pool.query(`
+      CREATE SCHEMA IF NOT EXISTS streamby;
+      CREATE EXTENSION IF NOT EXISTS "uuid-ossp";
+      CREATE TABLE IF NOT EXISTS streamby.projects (
+        id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+        name VARCHAR(255) NOT NULL,
+        description TEXT,
+        image TEXT,
+        "createdAt" TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
+        "updatedAt" TIMESTAMP WITH TIME ZONE DEFAULT NOW()
+      );
     `);
         console.log('✅ "projects" table ensured to exist.');
         // Ensure dbType column exists and is correctly configured
-        await pool.query(`
-      ALTER TABLE streamby.projects ADD COLUMN IF NOT EXISTS "dbType" VARCHAR(50);
+        await pool.query(`
+      ALTER TABLE streamby.projects ADD COLUMN IF NOT EXISTS "dbType" VARCHAR(50);
     `);
-        await pool.query(`
-      UPDATE streamby.projects SET "dbType" = 'nosql' WHERE "dbType" IS NULL;
+        await pool.query(`
+      UPDATE streamby.projects SET "dbType" = 'nosql' WHERE "dbType" IS NULL;
     `);
-        await pool.query(`
-      ALTER TABLE streamby.projects ALTER COLUMN "dbType" SET NOT NULL;
+        await pool.query(`
+      ALTER TABLE streamby.projects ALTER COLUMN "dbType" SET NOT NULL;
     `);
-        await pool.query(`
-      ALTER TABLE streamby.projects ALTER COLUMN "dbType" SET DEFAULT 'nosql';
+        await pool.query(`
+      ALTER TABLE streamby.projects ALTER COLUMN "dbType" SET DEFAULT 'nosql';
     `);
-        await pool.query(`
-      CREATE TABLE IF NOT EXISTS streamby.exports (
-        id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
-        "projectId" UUID 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 UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+        "projectId" UUID 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.');
-        await pool.query(`
-      CREATE TABLE IF NOT EXISTS streamby.project_members (
-        id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
-        "projectId" UUID NOT NULL REFERENCES streamby.projects(id) ON DELETE CASCADE,
-        "userId" VARCHAR(255) NOT NULL,
-        role VARCHAR(255) NOT NULL DEFAULT 'member',
-        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 UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+        "projectId" UUID NOT NULL REFERENCES streamby.projects(id) ON DELETE CASCADE,
+        "userId" VARCHAR(255) NOT NULL,
+        role VARCHAR(255) NOT NULL DEFAULT 'member',
+        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")
+      );
     `);
         console.log('✅ "project_members" table ensured to exist.');
     }

package/dist/adapters/database/sql.js

@@ -5,13 +5,13 @@ const createSQLExportTable = async (connection, projectId, exportName, fields) =
     const slug = exportName.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
     const tableName = `export_${projectId}_${slug}`;
     const columns = fields.map(field => `"${field.name}" ${field.type}`).join(',');
-    const createTableQuery = `
-    CREATE TABLE IF NOT EXISTS "${tableName}" (
-      id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
-      "projectId" UUID NOT NULL,
-      __metadata JSONB NOT NULL,
-      ${columns ? `, ${columns}` : ''}
-    );
+    const createTableQuery = `
+    CREATE TABLE IF NOT EXISTS "${tableName}" (
+      id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+      "projectId" UUID NOT NULL,
+      __metadata JSONB NOT NULL,
+      ${columns ? `, ${columns}` : ''}
+    );
   `;
     await connection.query(createTableQuery);
     console.log(`✅ Table '${tableName}' created with metadata.`);
@@ -29,11 +29,11 @@ exports.createSQLExportTable = createSQLExportTable;
 const createSQLRawExportTable = async (connection, projectId, exportName, jsonData) => {
     const slug = exportName.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
     const tableName = `raw_export_${projectId}_${slug}`;
-    const createTableQuery = `
-    CREATE TABLE IF NOT EXISTS "${tableName}" (
-      id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
-      data JSONB NOT NULL
-    );
+    const createTableQuery = `
+    CREATE TABLE IF NOT EXISTS "${tableName}" (
+      id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+      data JSONB NOT NULL
+    );
   `;
     await connection.query(createTableQuery);
     console.log(`✅ Raw table '${tableName}' created.`);

package/dist/adapters/storage/s3.d.ts

@@ -1,4 +1,4 @@
-import { S3Config, StorageAdapter } from '../../types';
+import { S3Config, StorageAdapter, StorageFileInfo } from '../../types';
 export declare class S3Adapter implements StorageAdapter {
     private s3;
     private bucket;
@@ -8,4 +8,9 @@ export declare class S3Adapter implements StorageAdapter {
     deleteProjectDirectory(projectId: string): Promise<any>;
     getPresignedUrl(contentType: string, projectId: string): Promise<any>;
     getPresignedProjectImageUrl(projectId: string): Promise<any>;
+    getPresignedGetUrl(key: string): Promise<string>;
+    getPresignedUploadUrl(key: string, contentType: string): Promise<string>;
+    deleteFile(key: string): Promise<void>;
+    listFilesByCategory(projectId: string, category: string): Promise<StorageFileInfo[]>;
+    private inferMimeType;
 }

package/dist/adapters/storage/s3.js

@@ -64,5 +64,53 @@ class S3Adapter {
         const publicUrl = `https://${this.bucket}.s3.amazonaws.com/${key}`;
         return { url, publicUrl };
     }
+    async getPresignedGetUrl(key) {
+        const command = new client_s3_1.GetObjectCommand({ Bucket: this.bucket, Key: key });
+        return await (0, s3_request_presigner_1.getSignedUrl)(this.s3, command, { expiresIn: 86400 });
+    }
+    async getPresignedUploadUrl(key, contentType) {
+        const command = new client_s3_1.PutObjectCommand({ Bucket: this.bucket, Key: key, ContentType: contentType });
+        return await (0, s3_request_presigner_1.getSignedUrl)(this.s3, command, { expiresIn: 3600 });
+    }
+    async deleteFile(key) {
+        const command = new client_s3_1.DeleteObjectCommand({ Bucket: this.bucket, Key: key });
+        await this.s3.send(command);
+    }
+    async listFilesByCategory(projectId, category) {
+        const prefix = `projects/${projectId}/${category}/`;
+        const command = new client_s3_1.ListObjectsV2Command({ Bucket: this.bucket, Prefix: prefix });
+        const result = await this.s3.send(command);
+        if (!result.Contents || result.Contents.length === 0)
+            return [];
+        const files = await Promise.all(result.Contents
+            .filter(obj => obj.Key && obj.Key !== prefix)
+            .map(async (obj) => {
+            const key = obj.Key;
+            const name = key.split('/').pop() || key;
+            const url = await this.getPresignedGetUrl(key);
+            return {
+                key,
+                name,
+                size: obj.Size || 0,
+                url,
+                contentType: this.inferMimeType(name),
+                lastModified: obj.LastModified?.toISOString() || new Date().toISOString(),
+                category,
+            };
+        }));
+        return files;
+    }
+    inferMimeType(filename) {
+        const ext = filename.split('.').pop()?.toLowerCase();
+        const mimeMap = {
+            jpg: 'image/jpeg', jpeg: 'image/jpeg', png: 'image/png', gif: 'image/gif',
+            webp: 'image/webp', svg: 'image/svg+xml', bmp: 'image/bmp', tiff: 'image/tiff',
+            mp3: 'audio/mpeg', wav: 'audio/wav', ogg: 'audio/ogg', aac: 'audio/aac', flac: 'audio/flac',
+            mp4: 'video/mp4', webm: 'video/webm', mov: 'video/quicktime', avi: 'video/x-msvideo',
+            glb: 'model/gltf-binary', gltf: 'model/gltf+json', obj: 'model/obj',
+            fbx: 'application/octet-stream', stl: 'model/stl', ply: 'model/ply',
+        };
+        return ext ? (mimeMap[ext] || 'application/octet-stream') : 'application/octet-stream';
+    }
 }
 exports.S3Adapter = S3Adapter;

package/dist/middleware/routes/export.js

@@ -50,6 +50,7 @@ function exportRouter(config) {
                         createdAt: rawData?.createdAt,
                         updatedAt: rawData?.updatedAt,
                         type: exportMetadata.type,
+                        fields: exportMetadata.fields,
                         description: rawData?.description,
                     };
                 }
@@ -75,8 +76,18 @@ function exportRouter(config) {
                         }
                     }
                     const externalApiData = await fetch(exportMetadata.apiUrl, { headers });
-                    const rawData = await externalApiData.json();
+                    const apiResponse = await externalApiData.json();
+                    let rawData;
+                    if (exportMetadata.fields && exportMetadata.fields.length > 0) {
+                        rawData = apiResponse.map((item) => {
+                            return exportMetadata.fields.reduce((filtered, field) => {
+                                filtered[field.name] = item[field.name];
+                                return filtered;
+                            }, {});
+                        });
+                    }
                     data = {
+                        apiResponse: apiResponse,
                         json: rawData || {},
                         name: exportMetadata.name,
                         createdAt: exportMetadata.createdAt,
@@ -85,6 +96,7 @@ function exportRouter(config) {
                         apiUrl: exportMetadata.apiUrl,
                         prefix: exportMetadata.prefix,
                         collectionName: exportMetadata.collectionName,
+                        fields: exportMetadata.fields,
                         description: exportMetadata?.description,
                     };
                 }
@@ -100,6 +112,7 @@ function exportRouter(config) {
                         type: exportMetadata.type,
                         credentialId: exportMetadata.credentialId,
                         description: rawData?.description,
+                        fields: exportMetadata.fields,
                     };
                 }
             }

package/dist/middleware/routes/storage.js

@@ -6,6 +6,28 @@ const file_1 = require("../../services/file");
 const presign_1 = require("../../services/presign");
 const storage_1 = require("../../providers/storage");
 const manager_1 = require("../../models/manager");
+const auth_1 = require("../../utils/auth");
+const VALID_CATEGORIES = ['images', 'audios', 'videos', '3dmodels'];
+const VALID_3D_EXTENSIONS = new Set(['.glb', '.gltf', '.obj', '.fbx', '.stl', '.ply']);
+function validateContentType(contentType, filename, category) {
+    if (category === 'images')
+        return contentType.startsWith('image/');
+    if (category === 'audios')
+        return contentType.startsWith('audio/');
+    if (category === 'videos')
+        return contentType.startsWith('video/');
+    if (category === '3dmodels') {
+        const ext = filename.split('.').pop()?.toLowerCase();
+        return ext ? VALID_3D_EXTENSIONS.has(`.${ext}`) : false;
+    }
+    return false;
+}
+function sanitizeFilename(filename) {
+    const dotIndex = filename.lastIndexOf('.');
+    const ext = dotIndex !== -1 ? filename.slice(dotIndex) : '';
+    const base = (dotIndex !== -1 ? filename.slice(0, dotIndex) : filename).replace(/[^a-zA-Z0-9._-]/g, '_');
+    return `${base}${ext}`;
+}
 function storageRouter(config) {
     const router = (0, express_1.Router)();
     const adapter = config.adapter || (0, storage_1.createStorageProvider)(config.storageProviders);
@@ -55,6 +77,99 @@ function storageRouter(config) {
             res.status(500).json({ message: 'Failed to delete image', details: err.message });
         }
     });
+    router.get('/projects/:projectId/storage/:category/upload-url', async (req, res) => {
+        try {
+            const auth = await config.authProvider(req);
+            if (!auth || !auth.userId || !auth.role) {
+                return res.status(401).json({ message: 'Unauthorized' });
+            }
+            const { projectId, category } = req.params;
+            const { fileName, contentType } = req.query;
+            if (!VALID_CATEGORIES.includes(category)) {
+                return res.status(400).json({ message: `Invalid category. Must be one of: ${VALID_CATEGORIES.join(', ')}` });
+            }
+            if (!fileName || !contentType) {
+                return res.status(400).json({ message: 'Query params fileName and contentType are required' });
+            }
+            if (!validateContentType(contentType, fileName, category)) {
+                const hint = category === '3dmodels'
+                    ? '.glb, .gltf, .obj, .fbx, .stl, or .ply'
+                    : `${category.slice(0, -1)}/* content type`;
+                return res.status(400).json({ message: `Files in the ${category} category must match ${hint}` });
+            }
+            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 access' });
+            }
+            if (!adapter.getPresignedUploadUrl) {
+                return res.status(501).json({ message: 'Storage adapter does not support presigned uploads' });
+            }
+            const key = `projects/${projectId}/${category}/${sanitizeFilename(fileName)}`;
+            const url = await adapter.getPresignedUploadUrl(key, contentType);
+            res.json({ url });
+        }
+        catch (err) {
+            res.status(500).json({ message: 'Failed to generate upload URL', details: err.message });
+        }
+    });
+    router.get('/projects/:projectId/storage/:category', async (req, res) => {
+        try {
+            const auth = await config.authProvider(req);
+            if (!auth || !auth.userId || !auth.role) {
+                return res.status(401).json({ message: 'Unauthorized' });
+            }
+            const { projectId, category } = req.params;
+            if (!VALID_CATEGORIES.includes(category)) {
+                return res.status(400).json({ message: `Invalid category. Must be one of: ${VALID_CATEGORIES.join(', ')}` });
+            }
+            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 access' });
+            }
+            if (!adapter.listFilesByCategory) {
+                return res.status(501).json({ message: 'Storage adapter does not support listing files by category' });
+            }
+            const files = await adapter.listFilesByCategory(projectId, category);
+            res.json({ data: files });
+        }
+        catch (err) {
+            res.status(500).json({ message: 'Failed to list files', details: err.message });
+        }
+    });
+    router.delete('/projects/:projectId/storage/:category/:key', async (req, res) => {
+        try {
+            const auth = await config.authProvider(req);
+            if (!auth || !auth.userId || !auth.role) {
+                return res.status(401).json({ message: 'Unauthorized' });
+            }
+            const { projectId, category } = req.params;
+            const key = decodeURIComponent(req.params.key);
+            if (!VALID_CATEGORIES.includes(category)) {
+                return res.status(400).json({ message: `Invalid category. Must be one of: ${VALID_CATEGORIES.join(', ')}` });
+            }
+            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 access' });
+            }
+            if (!adapter.deleteFile) {
+                return res.status(501).json({ message: 'Storage adapter does not support file deletion' });
+            }
+            await adapter.deleteFile(key);
+            res.json({ message: 'File deleted successfully.' });
+        }
+        catch (err) {
+            res.status(500).json({ message: 'Failed to delete file', details: err.message });
+        }
+    });
     router.get('/storages', async (req, res) => {
         try {
             const auth = await config.authProvider(req);

package/dist/types/index.d.ts

@@ -10,12 +10,25 @@ export type StorageProvider = {
     type: StorageProviderType;
     config: S3Config;
 };
+export interface StorageFileInfo {
+    key: string;
+    name: string;
+    size: number;
+    url: string;
+    contentType: string;
+    lastModified: string;
+    category: string;
+}
 export interface StorageAdapter {
     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>;
+    getPresignedUploadUrl?: (key: string, contentType: string) => Promise<string>;
+    listFilesByCategory?: (projectId: string, category: string) => Promise<StorageFileInfo[]>;
+    deleteFile?: (key: string) => Promise<void>;
+    getPresignedGetUrl?: (key: string) => Promise<string>;
 }
 export interface FieldDefinition {
     name: string;

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,61 +1,61 @@
-{
-  "name": "streamby-core",
-  "version": "0.24.16",
-  "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",
-    "pg": "^8.16.3",
-    "prisma": "^6.12.0",
-    "node-fetch": "^3.0.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",
-    "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.25.00",
+  "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",
+    "pg": "^8.16.3",
+    "prisma": "^6.12.0",
+    "node-fetch": "^3.0.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",
+    "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"
+  }
+}