streamby-core 0.29.12 → 0.31.0

package/dist/middleware/routes/renderFarm.js

@@ -9,6 +9,7 @@ const manager_1 = require("../../models/manager");
 const auth_1 = require("../../utils/auth");
 const jobQueue_1 = require("../../services/jobQueue");
 const vfxProcessor_1 = require("../../services/vfxProcessor");
+const sanitize_1 = require("../../utils/sanitize");
 const crypto_1 = __importDefault(require("crypto"));
 function renderFarmRouter(_config) {
     const router = (0, express_1.Router)();
@@ -23,7 +24,7 @@ function renderFarmRouter(_config) {
                 return res.status(404).json({ message: 'Project not found' });
             if (!(0, auth_1.isProjectMember)(project, auth.userId))
                 return res.status(403).json({ message: 'Unauthorized' });
-            res.json({ connections: project.renderFarmConnections ?? [] });
+            res.json({ connections: (0, sanitize_1.sanitizeConnections)(project.renderFarmConnections) });
         }
         catch (err) {
             res.status(500).json({ message: err.message });
@@ -33,7 +34,7 @@ function renderFarmRouter(_config) {
         try {
             const auth = req.auth;
             const { projectId } = req.params;
-            const { name, provider, apiUrl, credentialId, description } = req.body;
+            const { name, provider, apiUrl, encryptedCredential, description } = req.body;
             if (!name || !provider || !apiUrl) {
                 return res.status(400).json({ message: 'name, provider and apiUrl are required' });
             }
@@ -47,13 +48,13 @@ function renderFarmRouter(_config) {
                 name,
                 provider,
                 apiUrl,
-                credentialId,
+                encryptedCredential,
                 description,
                 projectId,
                 createdAt: new Date(),
             };
             await Project.update({ _id: projectId }, { $push: { renderFarmConnections: connection } });
-            res.status(201).json({ connection });
+            res.status(201).json({ connection: (0, sanitize_1.sanitizeConnection)(connection) });
         }
         catch (err) {
             res.status(500).json({ message: err.message });

package/dist/middleware/routes/storage.js

@@ -98,11 +98,10 @@ function storageRouter(config) {
         }
         if (!(0, encryption_1.isEncryptionKeySet)())
             return { error: 'Encryption key not set', status: 500 };
-        const credential = project.credentials?.find((c) => c.id === conn.credentialId);
-        if (!credential)
-            return { error: 'Credential not found in project', status: 400 };
+        if (!conn.encryptedCredential)
+            return { error: 'Connection has no stored credential', status: 400 };
         try {
-            const s3Config = JSON.parse((0, encryption_1.decrypt)(credential.encryptedValue));
+            const s3Config = JSON.parse((0, encryption_1.decrypt)(conn.encryptedCredential));
             return new s3_1.S3Adapter(s3Config);
         }
         catch (e) {

package/dist/middleware/routes/storageConnection.js

@@ -6,6 +6,8 @@ const mongodb_1 = require("mongodb");
 const manager_1 = require("../../models/manager");
 const auth_1 = require("../../utils/auth");
 const builtinAccess_1 = require("../../utils/builtinAccess");
+const sanitize_1 = require("../../utils/sanitize");
+const encryption_1 = require("../../utils/encryption");
 const VALID_STORAGE_TYPES = ['s3', 'gcs', 'r2', 'azure'];
 function storageConnectionRouter(config) {
     const router = (0, express_1.Router)();
@@ -24,9 +26,9 @@ function storageConnectionRouter(config) {
             // "validate on every use" (TCORE-69). BYOC (source: 'integration') is always available.
             const data = await Promise.all(connections.map(async (conn) => {
                 if (conn.source !== 'builtin')
-                    return conn;
+                    return (0, sanitize_1.sanitizeConnection)(conn);
                 const available = await (0, builtinAccess_1.assertBuiltinAccess)(auth, conn.integrationId ?? conn.id, config, 'storage');
-                return { ...conn, isBuiltin: true, available };
+                return (0, sanitize_1.sanitizeConnection)({ ...conn, isBuiltin: true, available });
             }));
             return res.status(200).json({ data });
         }
@@ -41,15 +43,15 @@ function storageConnectionRouter(config) {
             if (auth.role !== 'admin' && auth.role !== 'editor') {
                 return res.status(403).json({ message: 'Permission denied' });
             }
-            const { name, type, credentialId, integrationId, description } = req.body;
+            const { name, type, credential, integrationId, description } = req.body;
             if (!name || !type) {
                 return res.status(400).json({ message: 'name and type are required' });
             }
-            if (!credentialId && !integrationId) {
-                return res.status(400).json({ message: 'Either credentialId or integrationId is required' });
+            if (!credential && !integrationId) {
+                return res.status(400).json({ message: 'Either credential or integrationId is required' });
             }
-            if (credentialId && integrationId) {
-                return res.status(400).json({ message: 'Provide only one of credentialId or integrationId' });
+            if (credential && integrationId) {
+                return res.status(400).json({ message: 'Provide only one of credential or integrationId' });
             }
             if (!VALID_STORAGE_TYPES.includes(type)) {
                 return res.status(400).json({ message: `type must be one of: ${VALID_STORAGE_TYPES.join(', ')}` });
@@ -59,6 +61,7 @@ function storageConnectionRouter(config) {
                 return res.status(404).json({ message: 'Project not found' });
             if (!(0, auth_1.isProjectMember)(project, auth.userId))
                 return res.status(403).json({ message: 'Unauthorized project access' });
+            let encryptedCredential;
             if (integrationId) {
                 const UserIntegrationModel = (0, manager_1.getModel)('user_integrations');
                 const integration = await UserIntegrationModel.findOne({ id: integrationId, userId: auth.userId });
@@ -68,23 +71,23 @@ function storageConnectionRouter(config) {
                     return res.status(400).json({ message: 'Integration is not a storage integration' });
             }
             else {
-                const credExists = project.credentials?.some((c) => c.id === credentialId);
-                if (!credExists)
-                    return res.status(400).json({ message: 'Credential not found in project' });
+                if (!(0, encryption_1.isEncryptionKeySet)())
+                    return res.status(500).json({ message: 'Encryption key is not set' });
+                encryptedCredential = (0, encryption_1.encrypt)(credential);
             }
             const connection = {
                 id: new mongodb_1.ObjectId().toHexString(),
                 name,
                 type,
-                credentialId: credentialId ?? '',
                 projectId: req.params.id,
                 createdAt: new Date(),
                 source: integrationId ? 'integration' : 'manual',
                 ...(integrationId && { integrationId }),
+                ...(encryptedCredential !== undefined && { encryptedCredential }),
                 ...(description !== undefined && { description }),
             };
             await Project.update({ _id: req.params.id }, { $push: { storageConnections: connection } });
-            return res.status(201).json({ data: connection });
+            return res.status(201).json({ data: (0, sanitize_1.sanitizeConnection)(connection) });
         }
         catch (err) {
             res.status(500).json({ message: 'Failed to add storage connection', details: err.message });

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/services/backfillBuiltinConnections.js

@@ -29,7 +29,6 @@ async function backfillBuiltinConnections(config) {
             id: crypto_1.default.randomUUID(),
             name: builtinAccess_1.BUILTIN_DB_DISPLAY[db.type] ?? db.type,
             dbType: db.type === 'sql' ? 'postgresql' : 'mongodb',
-            credentialId: '',
             projectId: project.id,
             createdAt: now,
             isBuiltin: true,
@@ -40,7 +39,6 @@ async function backfillBuiltinConnections(config) {
             id: crypto_1.default.randomUUID(),
             name: builtinAccess_1.BUILTIN_STORAGE_DISPLAY[provider.type] ?? provider.type,
             type: provider.type,
-            credentialId: '',
             projectId: project.id,
             createdAt: now,
             isBuiltin: true,

package/dist/services/connection.d.ts

@@ -0,0 +1,18 @@
+import { StreamByConfig, Connection, ConnectionMethod } from '../types';
+export declare function addConnection(config: StreamByConfig, projectId: string, data: {
+    name: string;
+    apiUrl: string;
+    method: ConnectionMethod;
+    prefix?: string;
+    description?: string;
+    token?: string;
+}): Promise<Connection>;
+export declare function updateConnection(config: StreamByConfig, projectId: string, connectionId: string, data: {
+    name?: string;
+    apiUrl?: string;
+    method?: ConnectionMethod;
+    prefix?: string;
+    description?: string;
+    token?: string;
+}): Promise<Connection>;
+export declare function deleteConnection(config: StreamByConfig, projectId: string, connectionId: string): Promise<void>;

package/dist/services/connection.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addConnection = addConnection;
+exports.updateConnection = updateConnection;
+exports.deleteConnection = deleteConnection;
+const mongodb_1 = require("mongodb");
+const manager_1 = require("../models/manager");
+const encryption_1 = require("../utils/encryption");
+async function addConnection(config, projectId, data) {
+    const ProjectModel = (0, manager_1.getModel)('projects');
+    const project = await ProjectModel.findOne({ _id: projectId });
+    if (!project) {
+        throw new Error('Project not found.');
+    }
+    let encryptedCredential;
+    if (data.token) {
+        if (!(0, encryption_1.isEncryptionKeySet)())
+            throw new Error('Encryption key is not set. Cannot encrypt credential.');
+        encryptedCredential = (0, encryption_1.encrypt)(data.token);
+    }
+    const connection = {
+        id: new mongodb_1.ObjectId().toHexString(),
+        name: data.name,
+        prefix: data.prefix,
+        apiUrl: data.apiUrl,
+        method: data.method,
+        projectId,
+        createdAt: new Date(),
+        ...(data.description !== undefined && { description: data.description }),
+        ...(encryptedCredential !== undefined && { encryptedCredential }),
+    };
+    const updatedProject = await ProjectModel.update({ _id: projectId }, { $push: { connections: connection } });
+    if (!updatedProject) {
+        throw new Error('Failed to add connection to project.');
+    }
+    return connection;
+}
+async function updateConnection(config, projectId, connectionId, data) {
+    const ProjectModel = (0, manager_1.getModel)('projects');
+    const project = await ProjectModel.findOne({ _id: projectId });
+    if (!project)
+        throw new Error('Project not found.');
+    const connections = project.connections ?? [];
+    const index = connections.findIndex((c) => c.id === connectionId);
+    if (index === -1)
+        throw new Error('Connection not found.');
+    let encryptedCredential;
+    if (data.token) {
+        if (!(0, encryption_1.isEncryptionKeySet)())
+            throw new Error('Encryption key is not set. Cannot encrypt credential.');
+        encryptedCredential = (0, encryption_1.encrypt)(data.token);
+    }
+    const updated = {
+        ...connections[index],
+        ...(data.name !== undefined && { name: data.name }),
+        ...(data.apiUrl !== undefined && { apiUrl: data.apiUrl }),
+        ...(data.method !== undefined && { method: data.method }),
+        ...(data.prefix !== undefined && { prefix: data.prefix }),
+        ...(data.description !== undefined && { description: data.description }),
+        ...(encryptedCredential !== undefined && { encryptedCredential }),
+    };
+    connections[index] = updated;
+    const result = await ProjectModel.update({ _id: projectId }, { $set: { connections } });
+    if (!result)
+        throw new Error('Failed to update connection.');
+    return updated;
+}
+async function deleteConnection(config, projectId, connectionId) {
+    const ProjectModel = (0, manager_1.getModel)('projects');
+    const project = await ProjectModel.findOne({ _id: projectId });
+    if (!project) {
+        throw new Error('Project not found.');
+    }
+    const updatedProject = await ProjectModel.update({ _id: projectId }, { $pull: { connections: { id: connectionId } } });
+    if (!updatedProject) {
+        throw new Error('Failed to delete connection from project.');
+    }
+}

package/dist/services/executor.js

@@ -114,22 +114,19 @@ async function executeExport(nodeSchema, project, config) {
                 dataResults.push(await fetchData(client, type));
             }
         }
-        else if (node.type === 'apiConnectionNode') {
-            const apiConnection = project.apiConnections?.find((c) => c.id === node.data?.connectionId);
-            if (!apiConnection)
+        else if (node.type === 'connectionNode') {
+            const connection = project.connections?.find((c) => c.id === node.data?.connectionId);
+            if (!connection)
                 continue;
             const headers = { 'Content-Type': 'application/json' };
-            if (apiConnection.credentialId && (0, encryption_1.isEncryptionKeySet)()) {
-                const credential = project.credentials?.find((c) => c.id === apiConnection.credentialId);
-                if (credential) {
-                    const decrypted = (0, encryption_1.decrypt)(credential.encryptedValue);
-                    const prefix = apiConnection.prefix ? `${apiConnection.prefix} ` : '';
-                    headers['Authorization'] = `${prefix}${decrypted}`;
-                }
+            if (connection.encryptedCredential && (0, encryption_1.isEncryptionKeySet)()) {
+                const decrypted = (0, encryption_1.decrypt)(connection.encryptedCredential);
+                const prefix = connection.prefix ? `${connection.prefix} ` : '';
+                headers['Authorization'] = `${prefix}${decrypted}`;
             }
-            const response = await fetch(apiConnection.apiUrl, { method: apiConnection.method || 'GET', headers });
+            const response = await fetch(connection.apiUrl, { method: connection.method || 'GET', headers });
             if (!response.ok)
-                throw new Error(`API connection fetch failed: ${response.statusText}`);
+                throw new Error(`Connection fetch failed: ${response.statusText}`);
             dataResults.push(await response.json());
         }
     }

package/dist/services/projectIntegration.js

@@ -22,7 +22,7 @@ async function classifyIntegrationId(id, auth, config, projectId) {
             kind: 'database',
             connection: {
                 id: crypto_1.default.randomUUID(), name: builtinAccess_1.BUILTIN_DB_DISPLAY[db.type] ?? db.type, dbType: db.type === 'sql' ? 'postgresql' : 'mongodb',
-                credentialId: '', projectId, createdAt: now, isBuiltin: true, integrationId: id, source: 'builtin',
+                projectId, createdAt: now, isBuiltin: true, integrationId: id, source: 'builtin',
             },
         };
     }
@@ -35,7 +35,7 @@ async function classifyIntegrationId(id, auth, config, projectId) {
             kind: 'storage',
             connection: {
                 id: crypto_1.default.randomUUID(), name: builtinAccess_1.BUILTIN_STORAGE_DISPLAY[provider.type] ?? provider.type, type: provider.type,
-                credentialId: '', projectId, createdAt: now, isBuiltin: true, integrationId: id, source: 'builtin',
+                projectId, createdAt: now, isBuiltin: true, integrationId: id, source: 'builtin',
             },
         };
     }
@@ -49,7 +49,7 @@ async function classifyIntegrationId(id, auth, config, projectId) {
             kind: 'database',
             connection: {
                 id: crypto_1.default.randomUUID(), name: integration.name, dbType: integration.provider,
-                credentialId: '', projectId, createdAt: now, isBuiltin: false, integrationId: id, source: 'integration',
+                projectId, createdAt: now, isBuiltin: false, integrationId: id, source: 'integration',
             },
         };
     }
@@ -57,7 +57,7 @@ async function classifyIntegrationId(id, auth, config, projectId) {
         kind: 'storage',
         connection: {
             id: crypto_1.default.randomUUID(), name: integration.name, type: integration.provider,
-            credentialId: '', projectId, createdAt: now, isBuiltin: false, integrationId: id, source: 'integration',
+            projectId, createdAt: now, isBuiltin: false, integrationId: id, source: 'integration',
         },
     };
 }

package/dist/types/index.d.ts

@@ -12,7 +12,7 @@ export interface StorageConnection {
     id: string;
     name: string;
     type: StorageConnectionType;
-    credentialId: string;
+    encryptedCredential?: string;
     projectId: string;
     createdAt: Date;
     description?: string;
@@ -73,29 +73,23 @@ export interface ProjectInfo {
         allowUpload?: boolean;
         allowSharing?: boolean;
     };
-    credentials?: Credential[];
-    apiConnections?: ApiConnection[];
+    connections?: Connection[];
     dbConnections?: DbConnection[];
     storageConnections?: StorageConnection[];
     pipelines?: PipelineRef[];
     builtinBackfilledAt?: Date;
 }
-export interface Credential {
-    id: string;
-    key: string;
-    encryptedValue: string;
-}
-export type ApiConnectionMethod = 'GET' | 'POST' | 'PATCH' | 'PUT' | 'DELETE';
-export interface ApiConnection {
+export type ConnectionMethod = 'GET' | 'POST' | 'PATCH' | 'PUT' | 'DELETE';
+export interface Connection {
     id: string;
     name: string;
     apiUrl: string;
-    method: ApiConnectionMethod;
+    method: ConnectionMethod;
     projectId: string;
     createdAt: Date;
     prefix?: string;
     description?: string;
-    credentialId?: string;
+    encryptedCredential?: string;
 }
 export interface ProjectListInfo {
     id: string;
@@ -153,7 +147,7 @@ export interface DbConnection {
     id: string;
     name: string;
     dbType: ExternalDbType;
-    credentialId: string;
+    encryptedCredential?: string;
     projectId: string;
     createdAt: Date;
     description?: string;
@@ -214,7 +208,7 @@ export interface Export {
     fields?: FieldDefinition[];
     jsonData?: any;
     apiUrl?: string;
-    credentialId?: string;
+    encryptedCredential?: string;
     prefix?: string;
     private?: boolean;
     allowedOrigin?: string[];
@@ -244,7 +238,7 @@ export interface DistributionConnection {
     id: string;
     name: string;
     target: DistributionTarget;
-    credentialId?: string;
+    encryptedCredential?: string;
     projectId: string;
     config: Record<string, string>;
     createdAt: Date;
@@ -289,7 +283,7 @@ export interface RenderFarmConnection {
     name: string;
     provider: RenderFarmProvider;
     apiUrl: string;
-    credentialId?: string;
+    encryptedCredential?: string;
     projectId: string;
     createdAt: Date;
     description?: 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/dist/utils/sanitize.d.ts

@@ -1,2 +1,12 @@
+export declare function sanitizeConnection<T extends {
+    encryptedCredential?: string;
+}>(conn: T): Omit<T, 'encryptedCredential'> & {
+    hasCredential: boolean;
+};
+export declare function sanitizeConnections<T extends {
+    encryptedCredential?: string;
+}>(conns: T[] | undefined): (Omit<T, 'encryptedCredential'> & {
+    hasCredential: boolean;
+})[];
 export declare function sanitizeProject(project: any): any;
 export declare function sanitizeUserIntegration(integration: any): any;

package/dist/utils/sanitize.js

@@ -1,13 +1,28 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.sanitizeConnection = sanitizeConnection;
+exports.sanitizeConnections = sanitizeConnections;
 exports.sanitizeProject = sanitizeProject;
 exports.sanitizeUserIntegration = sanitizeUserIntegration;
+function sanitizeConnection(conn) {
+    const { encryptedCredential, ...rest } = conn;
+    return { ...rest, hasCredential: !!encryptedCredential };
+}
+function sanitizeConnections(conns) {
+    return (conns ?? []).map(sanitizeConnection);
+}
 function sanitizeProject(project) {
     if (!project)
         return project;
     return {
         ...project,
-        credentials: project.credentials?.map(({ id, key }) => ({ id, key })) ?? [],
+        credentials: undefined,
+        connections: sanitizeConnections(project.connections),
+        storageConnections: sanitizeConnections(project.storageConnections),
+        dbConnections: sanitizeConnections(project.dbConnections),
+        distributionConnections: sanitizeConnections(project.distributionConnections),
+        renderFarmConnections: sanitizeConnections(project.renderFarmConnections),
+        exports: project.exports?.map((e) => e && 'encryptedCredential' in e ? sanitizeConnection(e) : e),
     };
 }
 function sanitizeUserIntegration(integration) {

package/package.json

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