streamby-core 0.26.10 → 0.27.0

package/dist/services/dbConnection.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listTablesOrCollections = listTablesOrCollections;
+exports.createTableOrCollection = createTableOrCollection;
+exports.queryRecords = queryRecords;
+exports.insertRecord = insertRecord;
+exports.listTablesInternal = listTablesInternal;
+exports.queryRecordsInternal = queryRecordsInternal;
+exports.createTableOrCollectionInternal = createTableOrCollectionInternal;
+exports.insertRecordInternal = insertRecordInternal;
+const pg_1 = require("pg");
+const mongodb_1 = require("mongodb");
+// ─── Ephemeral connection helpers ─────────────────────────────────────────────
+async function withPostgres(connectionString, fn) {
+    const client = new pg_1.Client({ connectionString });
+    await client.connect();
+    try {
+        return await fn(client);
+    }
+    finally {
+        await client.end();
+    }
+}
+async function withMongo(connectionString, fn) {
+    const mongo = new mongodb_1.MongoClient(connectionString);
+    await mongo.connect();
+    try {
+        return await fn(mongo.db());
+    }
+    finally {
+        await mongo.close();
+    }
+}
+// ─── Operations ───────────────────────────────────────────────────────────────
+async function listTablesOrCollections(connectionString, dbType) {
+    if (dbType === 'postgresql') {
+        return withPostgres(connectionString, async (client) => {
+            const result = await client.query(`SELECT table_name FROM information_schema.tables WHERE table_schema = 'public' ORDER BY table_name`);
+            return result.rows.map(r => r.table_name);
+        });
+    }
+    return withMongo(connectionString, async (db) => {
+        const cols = await db.listCollections().toArray();
+        return cols.map(c => c.name).sort();
+    });
+}
+async function createTableOrCollection(connectionString, dbType, schema) {
+    if (dbType === 'postgresql') {
+        const columnDdl = schema.columns.map(col => {
+            const nullable = col.nullable === false ? 'NOT NULL' : '';
+            const pk = col.primaryKey ? 'PRIMARY KEY' : '';
+            return `"${col.name}" ${col.type} ${nullable} ${pk}`.trim();
+        }).join(', ');
+        const ddl = `CREATE TABLE IF NOT EXISTS "${schema.tableName}" (${columnDdl})`;
+        await withPostgres(connectionString, client => client.query(ddl).then(() => undefined));
+        return;
+    }
+    await withMongo(connectionString, async (db) => {
+        await db.createCollection(schema.tableName);
+    });
+}
+async function queryRecords(connectionString, dbType, tableName, limit = 50, offset = 0) {
+    if (dbType === 'postgresql') {
+        return withPostgres(connectionString, async (client) => {
+            const result = await client.query(`SELECT * FROM "${tableName}" LIMIT $1 OFFSET $2`, [limit, offset]);
+            return result.rows;
+        });
+    }
+    return withMongo(connectionString, async (db) => {
+        return db.collection(tableName).find().limit(limit).skip(offset).toArray();
+    });
+}
+async function insertRecord(connectionString, dbType, tableName, record) {
+    if (dbType === 'postgresql') {
+        return withPostgres(connectionString, async (client) => {
+            const keys = Object.keys(record);
+            const values = Object.values(record);
+            const cols = keys.map(k => `"${k}"`).join(', ');
+            const placeholders = keys.map((_, i) => `$${i + 1}`).join(', ');
+            const result = await client.query(`INSERT INTO "${tableName}" (${cols}) VALUES (${placeholders}) RETURNING *`, values);
+            return result.rows[0];
+        });
+    }
+    return withMongo(connectionString, async (db) => {
+        const result = await db.collection(tableName).insertOne(record);
+        return { ...record, _id: result.insertedId };
+    });
+}
+// ─── Internal (pool-based) variants ──────────────────────────────────────────
+// These operate on already-connected Pool / MongoClient from connectionManager.
+function quoteSqlTable(tableName) {
+    const parts = tableName.split('.');
+    return parts.length === 2 ? `"${parts[0]}"."${parts[1]}"` : `"${tableName}"`;
+}
+async function listTablesInternal(client, dbType, projectId) {
+    const prefix = projectId ? `db_${projectId}_` : null;
+    if (dbType === 'sql') {
+        const result = await client.query(`SELECT table_schema, table_name
+       FROM information_schema.tables
+       WHERE table_type = 'BASE TABLE'
+         AND table_schema NOT IN ('information_schema', 'pg_catalog', 'pg_toast')
+         ${prefix ? `AND table_name LIKE $1` : ''}
+       ORDER BY table_schema, table_name`, prefix ? [`${prefix}%`] : []);
+        return result.rows.map(r => {
+            const full = r.table_schema === 'public' ? r.table_name : `${r.table_schema}.${r.table_name}`;
+            return prefix ? full.slice(prefix.length) : full;
+        });
+    }
+    const cols = await client.db().listCollections().toArray();
+    const names = cols.map(c => c.name).sort();
+    if (!prefix)
+        return names;
+    return names.filter(n => n.startsWith(prefix)).map(n => n.slice(prefix.length));
+}
+async function queryRecordsInternal(client, dbType, tableName, limit = 50, offset = 0, projectId) {
+    const fullName = projectId ? `db_${projectId}_${tableName}` : tableName;
+    if (dbType === 'sql') {
+        const result = await client.query(`SELECT * FROM ${quoteSqlTable(fullName)} LIMIT $1 OFFSET $2`, [limit, offset]);
+        return result.rows;
+    }
+    return client.db().collection(fullName).find().limit(limit).skip(offset).toArray();
+}
+async function createTableOrCollectionInternal(client, dbType, schema, projectId) {
+    const fullName = projectId ? `db_${projectId}_${schema.tableName}` : schema.tableName;
+    if (dbType === 'sql') {
+        const columnDdl = schema.columns.map(col => {
+            const nullable = col.nullable === false ? 'NOT NULL' : '';
+            const pk = col.primaryKey ? 'PRIMARY KEY' : '';
+            return `"${col.name}" ${col.type} ${nullable} ${pk}`.trim();
+        }).join(', ');
+        await client.query(`CREATE TABLE IF NOT EXISTS ${quoteSqlTable(fullName)} (${columnDdl})`);
+        return;
+    }
+    await client.db().createCollection(fullName);
+}
+async function insertRecordInternal(client, dbType, tableName, record, projectId) {
+    const fullName = projectId ? `db_${projectId}_${tableName}` : tableName;
+    if (dbType === 'sql') {
+        const keys = Object.keys(record);
+        const values = Object.values(record);
+        const cols = keys.map(k => `"${k}"`).join(', ');
+        const placeholders = keys.map((_, i) => `$${i + 1}`).join(', ');
+        const result = await client.query(`INSERT INTO ${quoteSqlTable(fullName)} (${cols}) VALUES (${placeholders}) RETURNING *`, values);
+        return result.rows[0];
+    }
+    const result = await client.db().collection(fullName).insertOne(record);
+    return { ...record, _id: result.insertedId };
+}

package/dist/services/export.d.ts

@@ -3,7 +3,7 @@ interface ExportResult {
     exportId: string;
     message: string;
 }
-export declare function createExport(config: StreamByConfig, projectId: string, description: string, exportName: string, dbType: DatabaseType, exportType: 'json' | 'externalApi', isPrivate?: boolean, allowedOrigin?: string[], nodeSchema?: NodeSchema, useConnections?: boolean, useCredentials?: boolean): Promise<ExportResult>;
+export declare function createExport(config: StreamByConfig, projectId: string, description: string, exportName: string, dbType: DatabaseType, exportType: 'json' | 'externalApi', isPrivate?: boolean, allowedOrigin?: string[], nodeSchema?: NodeSchema, useConnections?: boolean, useCredentials?: boolean, storageDbId?: string): Promise<ExportResult>;
 export declare function updateExport(config: StreamByConfig, projectId: string, exportId: string, description: string, exportName: string, dbType: DatabaseType, exportType: 'json' | 'externalApi', isPrivate?: boolean, allowedOrigin?: string[], nodeSchema?: NodeSchema, useConnections?: boolean, useCredentials?: boolean): Promise<ExportResult>;
 export declare function deleteExport(config: StreamByConfig, projectId: string, exportId: string, dbType: DatabaseType, exportName: string): Promise<{
     message: string;

package/dist/services/export.js

@@ -8,65 +8,113 @@ const mongodb_1 = require("mongodb");
 const connectionManager_1 = require("../adapters/database/connectionManager");
 const nosql_1 = require("../adapters/database/nosql");
 const sql_1 = require("../adapters/database/sql");
-async function createExport(config, projectId, description, exportName, dbType, exportType, isPrivate, allowedOrigin, nodeSchema, useConnections, useCredentials) {
-    const targetDb = config.databases?.find(db => db.type === dbType && db.main) ||
-        config.databases?.find(db => db.type === dbType);
+async function createExport(config, projectId, description, exportName, dbType, exportType, isPrivate, allowedOrigin, nodeSchema, useConnections, useCredentials, storageDbId) {
+    const targetDb = storageDbId
+        ? config.databases?.find(db => db.id === storageDbId)
+        : config.databases?.find(db => db.type === dbType && db.main) ||
+            config.databases?.find(db => db.type === dbType);
     if (!targetDb) {
         throw new Error(`Database connection not found for type ${dbType}`);
     }
     const connection = (0, connectionManager_1.getConnection)(targetDb.id);
+    const resolvedDbType = targetDb.type;
     let exportId;
-    if (dbType === 'nosql') {
+    if (resolvedDbType === 'nosql') {
         const result = await (0, nosql_1.createNoSQLRawExportCollection)(connection.client, projectId, exportName, 'GET', nodeSchema);
         exportId = result.exportId;
     }
-    else if (dbType === 'sql') {
+    else if (resolvedDbType === 'sql') {
         const result = await (0, sql_1.createSQLRawExportTable)(connection.client, projectId, exportName, nodeSchema);
         exportId = result.exportId;
     }
     else {
         throw new Error('Unsupported database type');
     }
-    const NoSQLProject = (0, manager_1.getModel)('projects', 'nosql');
-    await NoSQLProject.update({ _id: projectId }, { $push: { exports: { id: new mongodb_1.ObjectId(exportId), name: exportName, type: exportType, method: 'GET', private: isPrivate, allowedOrigin, nodeSchema, useConnections, useCredentials, description } } });
+    // Route the project document update to the correct DB based on where the project lives
+    const Project = (0, manager_1.getModel)('projects');
+    const project = await Project.findOne({ _id: projectId });
+    const isSqlProject = project?.dbType === 'sql';
+    const exportEntry = {
+        id: isSqlProject ? exportId : new mongodb_1.ObjectId(exportId),
+        name: exportName,
+        type: exportType,
+        method: 'GET',
+        private: isPrivate,
+        allowedOrigin,
+        nodeSchema,
+        useConnections,
+        useCredentials,
+        description,
+        storageDbId: targetDb.id,
+    };
+    const ProjectModel = isSqlProject ? (0, manager_1.getModel)('projects', 'sql') : (0, manager_1.getModel)('projects', 'nosql');
+    await ProjectModel.update({ _id: projectId }, { $push: { exports: exportEntry } });
     return { exportId, message: `${exportType} export created successfully` };
 }
 async function updateExport(config, projectId, exportId, description, exportName, dbType, exportType, isPrivate, allowedOrigin, nodeSchema, useConnections, useCredentials) {
-    const targetDb = config.databases?.find(db => db.type === dbType && db.main) ||
-        config.databases?.find(db => db.type === dbType);
+    // Resolve the project to find where its raw export data lives
+    const Project = (0, manager_1.getModel)('projects');
+    const project = await Project.findOne({ _id: projectId });
+    const isSqlProject = project?.dbType === 'sql';
+    // Find storageDbId from the export entry, or fall back to the legacy dbType lookup
+    const exportEntry = project?.exports?.find((e) => String(e.id) === exportId);
+    const resolvedStorageDbId = exportEntry?.storageDbId;
+    const targetDb = resolvedStorageDbId
+        ? config.databases?.find(db => db.id === resolvedStorageDbId)
+        : config.databases?.find(db => db.type === dbType && db.main) ||
+            config.databases?.find(db => db.type === dbType);
     if (!targetDb) {
         throw new Error(`Database connection not found for type ${dbType}`);
     }
     const connection = (0, connectionManager_1.getConnection)(targetDb.id);
-    if (dbType === 'nosql') {
+    if (targetDb.type === 'nosql') {
         const db = connection.client.db();
         await db.collection(projectId).updateOne({ _id: new mongodb_1.ObjectId(exportId) }, { $set: { nodeSchema, description, updatedAt: new Date() } });
     }
+    // SQL raw export table update would go here if needed in future
+    // Update the export entry in the project document
+    if (isSqlProject) {
+        // For SQL projects: read-modify-write the exports JSONB array
+        const SqlProject = (0, manager_1.getModel)('projects', 'sql');
+        const currentExports = project?.exports ?? [];
+        const updatedExports = currentExports.map((e) => String(e.id) === exportId
+            ? { ...e, name: exportName, private: isPrivate, allowedOrigin, nodeSchema, useConnections, useCredentials, description }
+            : e);
+        await SqlProject.update({ _id: projectId }, { exports: updatedExports });
+    }
     else {
-        throw new Error('Unsupported database type for update');
+        const NoSQLProject = (0, manager_1.getModel)('projects', 'nosql');
+        await NoSQLProject.update({ _id: new mongodb_1.ObjectId(projectId), 'exports.id': { $in: [new mongodb_1.ObjectId(exportId), exportId] } }, { $set: { 'exports.$.name': exportName, 'exports.$.private': isPrivate, 'exports.$.allowedOrigin': allowedOrigin, 'exports.$.nodeSchema': nodeSchema, 'exports.$.useConnections': useConnections, 'exports.$.useCredentials': useCredentials, 'exports.$.description': description } });
     }
-    const NoSQLProject = (0, manager_1.getModel)('projects', 'nosql');
-    await NoSQLProject.update({
-        _id: new mongodb_1.ObjectId(projectId),
-        'exports.id': { $in: [new mongodb_1.ObjectId(exportId), exportId] }
-    }, { $set: { 'exports.$.name': exportName, 'exports.$.private': isPrivate, 'exports.$.allowedOrigin': allowedOrigin, 'exports.$.nodeSchema': nodeSchema, 'exports.$.useConnections': useConnections, 'exports.$.useCredentials': useCredentials, 'exports.$.description': description } });
     return { exportId, message: `${exportType} export updated successfully` };
 }
 async function deleteExport(config, projectId, exportId, dbType, exportName) {
-    const targetDb = config.databases?.find(db => db.type === dbType && db.main) ||
-        config.databases?.find(db => db.type === dbType);
+    // Resolve the project to find where its raw export data lives
+    const Project = (0, manager_1.getModel)('projects');
+    const project = await Project.findOne({ _id: projectId });
+    const isSqlProject = project?.dbType === 'sql';
+    const exportEntry = project?.exports?.find((e) => String(e.id) === exportId);
+    const resolvedStorageDbId = exportEntry?.storageDbId;
+    const targetDb = resolvedStorageDbId
+        ? config.databases?.find(db => db.id === resolvedStorageDbId)
+        : config.databases?.find(db => db.type === dbType && db.main) ||
+            config.databases?.find(db => db.type === dbType);
     if (!targetDb) {
         throw new Error(`Database connection not found for type ${dbType}`);
     }
     const connection = (0, connectionManager_1.getConnection)(targetDb.id);
-    if (dbType === 'nosql') {
+    if (targetDb.type === 'nosql') {
         const db = connection.client.db();
         await db.collection(projectId).deleteOne({ _id: new mongodb_1.ObjectId(exportId) });
     }
+    // SQL raw export table row deletion would go here if needed in future
+    if (isSqlProject) {
+        const SqlProject = (0, manager_1.getModel)('projects', 'sql');
+        await SqlProject.update({ _id: projectId }, { $pull: { exports: { id: exportId } } });
+    }
     else {
-        throw new Error('Unsupported database type for delete');
+        const NoSQLProject = (0, manager_1.getModel)('projects', 'nosql');
+        await NoSQLProject.update({ _id: new mongodb_1.ObjectId(projectId) }, { $pull: { exports: { id: new mongodb_1.ObjectId(exportId) } } });
     }
-    const NoSQLProject = (0, manager_1.getModel)('projects', 'nosql');
-    await NoSQLProject.update({ _id: new mongodb_1.ObjectId(projectId) }, { $pull: { exports: { id: new mongodb_1.ObjectId(exportId) } } });
     return { message: 'Export deleted successfully' };
 }

package/dist/services/pipeline.js

@@ -3,6 +3,62 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.executePipeline = executePipeline;
 const connectionManager_1 = require("../adapters/database/connectionManager");
 const encryption_1 = require("../utils/encryption");
+function applyFilterConfig(payload, config) {
+    const isArr = Array.isArray(payload);
+    let r = isArr ? [...payload] : payload;
+    if (config.conditions?.length) {
+        const matches = (item) => config.conditions.every(c => {
+            const v = item?.[c.field];
+            switch (c.op) {
+                case 'eq': return String(v) === c.value;
+                case 'neq': return String(v) !== c.value;
+                case 'gt': return Number(v) > Number(c.value);
+                case 'lt': return Number(v) < Number(c.value);
+                case 'gte': return Number(v) >= Number(c.value);
+                case 'lte': return Number(v) <= Number(c.value);
+                case 'contains': return String(v).includes(c.value);
+                case 'startsWith': return String(v).startsWith(c.value);
+                case 'endsWith': return String(v).endsWith(c.value);
+                default: return true;
+            }
+        });
+        r = isArr ? r.filter(matches) : (matches(r) ? r : null);
+        if (r === null)
+            return null;
+    }
+    if (config.includeFields?.length) {
+        const pick = (item) => {
+            if (!item || typeof item !== 'object')
+                return item;
+            const o = {};
+            for (const f of config.includeFields)
+                if (f in item)
+                    o[f] = item[f];
+            return o;
+        };
+        r = isArr ? r.map(pick) : pick(r);
+    }
+    if (config.renameFields?.length) {
+        const ren = (item) => {
+            if (!item || typeof item !== 'object')
+                return item;
+            const o = { ...item };
+            for (const { from, to } of config.renameFields) {
+                if (from in o) {
+                    o[to] = o[from];
+                    delete o[from];
+                }
+            }
+            return o;
+        };
+        r = isArr ? r.map(ren) : ren(r);
+    }
+    if (config.limit && isArr)
+        r = r.slice(0, config.limit);
+    if (config.wrapKey)
+        r = { [config.wrapKey]: r };
+    return r;
+}
 function getSources(nodes, edges, targetId, targetHandle) {
     return edges
         .filter(e => e.target === targetId && e.targetHandle === targetHandle)
@@ -69,7 +125,9 @@ async function executePipeline(nodeSchema, project, config) {
     // 3. Filter layer — chain from streamby out-right → filterNode in-filter → out-filter → ...
     let filterNode = getTarget(nodes, edges, 'streamby', 'out-right');
     while (filterNode) {
-        // filter logic per filterNode.data.label — pass-through until defined
+        const cfg = filterNode.data?.filterConfig;
+        if (cfg)
+            payload = applyFilterConfig(payload, cfg);
         filterNode = getTarget(nodes, edges, filterNode.id, 'out-filter');
     }
     return payload;

package/dist/types/index.d.ts

@@ -40,7 +40,7 @@ export interface FieldDefinition {
 export interface ProjectInfo {
     _id?: string;
     id: string;
-    dbType: DatabaseType;
+    dbType?: DatabaseType;
     name: string;
     image?: string;
     members?: {
@@ -59,6 +59,7 @@ export interface ProjectInfo {
     };
     credentials?: Credential[];
     apiConnections?: ApiConnection[];
+    dbConnections?: DbConnection[];
 }
 export interface Credential {
     id: string;
@@ -79,7 +80,7 @@ export interface ApiConnection {
 }
 export interface ProjectListInfo {
     id: string;
-    dbType: DatabaseType;
+    dbType?: DatabaseType;
     name: string;
     image?: string;
     archived: boolean;
@@ -122,6 +123,26 @@ export interface Auth {
     role: 'viewer' | 'editor' | 'admin';
 }
 export type AuthProvider = (req: Request) => Promise<Auth>;
+export type ExternalDbType = 'postgresql' | 'mongodb';
+export interface DbConnection {
+    id: string;
+    name: string;
+    dbType: ExternalDbType;
+    credentialId: string;
+    projectId: string;
+    createdAt: Date;
+    description?: string;
+}
+export interface ColumnDefinition {
+    name: string;
+    type: string;
+    nullable?: boolean;
+    primaryKey?: boolean;
+}
+export interface CreateTableSchema {
+    tableName: string;
+    columns: ColumnDefinition[];
+}
 export interface NodeSchema {
     nodes: any[];
     edges: any[];
@@ -143,4 +164,5 @@ export interface Export {
     nodeSchema?: NodeSchema;
     useConnections?: boolean;
     useCredentials?: boolean;
+    storageDbId?: 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,63 +1,63 @@
-{
-  "name": "streamby-core",
-  "version": "0.26.10",
-  "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.27.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",
+    "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"
+  }
+}