streamby-core 0.26.0 → 0.26.2

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

@@ -5,7 +5,7 @@ export declare const createNoSQLExportCollection: (connection: MongoClient, proj
     collectionName: string;
     exportId: string;
 }>;
-export declare const createNoSQLRawExportCollection: (connection: MongoClient, exportName: string, method: string, nodeSchema?: NodeSchema) => Promise<{
+export declare const createNoSQLRawExportCollection: (connection: MongoClient, projectId: string, exportName: string, method: string, nodeSchema?: NodeSchema) => Promise<{
     collectionName: string;
     exportId: string;
 }>;

package/dist/adapters/database/nosql.js

@@ -33,12 +33,10 @@ const createNoSQLExportCollection = async (connection, projectId, exportName, fi
     return { collectionName, exportId: collectionName };
 };
 exports.createNoSQLExportCollection = createNoSQLExportCollection;
-const createNoSQLRawExportCollection = async (connection, exportName, method, nodeSchema) => {
+const createNoSQLRawExportCollection = async (connection, projectId, exportName, method, nodeSchema) => {
     const db = connection.db();
-    const slug = exportName.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
-    const collectionName = slug;
+    const collectionName = projectId;
     const result = await db.collection(collectionName).insertOne({ nodeSchema, name: exportName, method, createdAt: new Date(), updatedAt: new Date() });
-    console.log(`✅ Raw collection '${collectionName}' created.`);
     return { collectionName, exportId: result.insertedId.toHexString() };
 };
 exports.createNoSQLRawExportCollection = createNoSQLRawExportCollection;

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

@@ -4,7 +4,7 @@ export declare const createSQLExportTable: (connection: Pool, projectId: string,
     collectionName: string;
     exportId: string;
 }>;
-export declare const createSQLRawExportTable: (connection: Pool, exportName: string, nodeSchema?: any) => Promise<{
+export declare const createSQLRawExportTable: (connection: Pool, projectId: string, exportName: string, nodeSchema?: any) => Promise<{
     collectionName: string;
     exportId: string;
 }>;

package/dist/adapters/database/sql.js

@@ -27,9 +27,8 @@ const createSQLExportTable = async (connection, projectId, exportName, fields) =
     return { collectionName: tableName, exportId: tableName };
 };
 exports.createSQLExportTable = createSQLExportTable;
-const createSQLRawExportTable = async (connection, exportName, nodeSchema) => {
-    const slug = exportName.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
-    const tableName = slug;
+const createSQLRawExportTable = async (connection, projectId, exportName, nodeSchema) => {
+    const tableName = projectId;
     const exportId = (0, crypto_1.randomUUID)();
     const createTableQuery = `
     CREATE TABLE IF NOT EXISTS "${tableName}" (

package/dist/middleware/routes/connection.js

@@ -68,9 +68,9 @@ function apiConnectionRouter(config) {
                 return res.status(403).json({ message: 'Permission denied' });
             }
             const projectId = req.params.id;
-            const { name, baseUrl, method, description, credentialId, prefix } = req.body;
-            if (!name || !baseUrl) {
-                return res.status(400).json({ message: 'name and baseUrl are required' });
+            const { name, apiUrl, method, description, credentialId, prefix } = req.body;
+            if (!name || !apiUrl) {
+                return res.status(400).json({ message: 'name and apiUrl are required' });
             }
             if (!VALID_METHODS.includes(method)) {
                 return res.status(400).json({ message: `method must be one of: ${VALID_METHODS.join(', ')}` });
@@ -90,7 +90,7 @@ function apiConnectionRouter(config) {
             }
             const connection = await (0, apiConnection_1.addApiConnection)(config, projectId, {
                 name,
-                baseUrl,
+                apiUrl,
                 method,
                 prefix,
                 ...(description !== undefined && { description }),
@@ -132,7 +132,7 @@ function apiConnectionRouter(config) {
                 const prefix = apiConnection.prefix ? `${apiConnection.prefix} ` : '';
                 headers['Authorization'] = `${prefix}${decrypted}`;
             }
-            const response = await fetch(apiConnection.baseUrl, { method: apiConnection.method || 'GET', headers });
+            const response = await fetch(apiConnection.apiUrl, { method: apiConnection.method || 'GET', headers });
             if (!response.ok) {
                 return res.status(response.status).json({ message: `External API error: ${response.statusText}` });
             }

package/dist/middleware/routes/export.js

@@ -200,7 +200,7 @@ function exportRouter(config) {
             if (!exportMetadata) {
                 return res.status(404).json({ message: 'Export not found' });
             }
-            const result = await (0, export_1.updateExport)(config, projectId, exportId, description, name, exportMetadata.name, project.dbType, exportType, isPrivate, allowedOrigin, nodeSchema, useConnections, useCredentials);
+            const result = await (0, export_1.updateExport)(config, projectId, exportId, description, name, project.dbType, exportType, isPrivate, allowedOrigin, nodeSchema, useConnections, useCredentials);
             res.status(200).json({ data: result, message: result.message });
         }
         catch (err) {

package/dist/services/apiConnection.d.ts

@@ -1,7 +1,7 @@
 import { StreamByConfig, ApiConnection, ApiConnectionMethod } from '../types';
 export declare function addApiConnection(config: StreamByConfig, projectId: string, data: {
     name: string;
-    baseUrl: string;
+    apiUrl: string;
     method: ApiConnectionMethod;
     prefix?: string;
     description?: string;

package/dist/services/apiConnection.js

@@ -14,7 +14,7 @@ async function addApiConnection(config, projectId, data) {
         id: new mongodb_1.ObjectId().toHexString(),
         name: data.name,
         prefix: data.prefix,
-        baseUrl: data.baseUrl,
+        apiUrl: data.apiUrl,
         method: data.method,
         projectId,
         createdAt: new Date(),

package/dist/services/export.d.ts

@@ -4,7 +4,7 @@ interface ExportResult {
     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 updateExport(config: StreamByConfig, projectId: string, exportId: string, description: string, exportName: string, storedExportName: string, dbType: DatabaseType, exportType: 'json' | 'externalApi', isPrivate?: boolean, allowedOrigin?: string[], nodeSchema?: NodeSchema, useConnections?: boolean, useCredentials?: boolean): 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

@@ -17,11 +17,11 @@ async function createExport(config, projectId, description, exportName, dbType,
     const connection = (0, connectionManager_1.getConnection)(targetDb.id);
     let exportId;
     if (dbType === 'nosql') {
-        const result = await (0, nosql_1.createNoSQLRawExportCollection)(connection.client, exportName, 'GET', nodeSchema);
+        const result = await (0, nosql_1.createNoSQLRawExportCollection)(connection.client, projectId, exportName, 'GET', nodeSchema);
         exportId = result.exportId;
     }
     else if (dbType === 'sql') {
-        const result = await (0, sql_1.createSQLRawExportTable)(connection.client, exportName, nodeSchema);
+        const result = await (0, sql_1.createSQLRawExportTable)(connection.client, projectId, exportName, nodeSchema);
         exportId = result.exportId;
     }
     else {
@@ -31,17 +31,16 @@ async function createExport(config, projectId, description, exportName, dbType,
     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 } } });
     return { exportId, message: `${exportType} export created successfully` };
 }
-async function updateExport(config, projectId, exportId, description, exportName, storedExportName, dbType, exportType, isPrivate, allowedOrigin, nodeSchema, useConnections, useCredentials) {
+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);
     if (!targetDb) {
         throw new Error(`Database connection not found for type ${dbType}`);
     }
     const connection = (0, connectionManager_1.getConnection)(targetDb.id);
-    const storedSlug = storedExportName.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
     if (dbType === 'nosql') {
         const db = connection.client.db();
-        await db.collection(storedSlug).updateOne({ _id: new mongodb_1.ObjectId(exportId) }, { $set: { nodeSchema, description, updatedAt: new Date() } });
+        await db.collection(projectId).updateOne({ _id: new mongodb_1.ObjectId(exportId) }, { $set: { nodeSchema, description, updatedAt: new Date() } });
     }
     else {
         throw new Error('Unsupported database type for update');
@@ -60,10 +59,9 @@ async function deleteExport(config, projectId, exportId, dbType, exportName) {
         throw new Error(`Database connection not found for type ${dbType}`);
     }
     const connection = (0, connectionManager_1.getConnection)(targetDb.id);
-    const slug = exportName.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
     if (dbType === 'nosql') {
         const db = connection.client.db();
-        await db.collection(slug).deleteOne({ _id: new mongodb_1.ObjectId(exportId) });
+        await db.collection(projectId).deleteOne({ _id: new mongodb_1.ObjectId(exportId) });
     }
     else {
         throw new Error('Unsupported database type for delete');

package/dist/services/pipeline.js

@@ -53,7 +53,7 @@ async function executePipeline(nodeSchema, project, config) {
                     headers['Authorization'] = `${prefix}${decrypted}`;
                 }
             }
-            const response = await fetch(apiConnection.baseUrl, { method: apiConnection.method || 'GET', headers });
+            const response = await fetch(apiConnection.apiUrl, { method: apiConnection.method || 'GET', headers });
             if (!response.ok)
                 throw new Error(`API connection fetch failed: ${response.statusText}`);
             dataResults.push(await response.json());

package/dist/types/index.d.ts

@@ -68,7 +68,7 @@ export type ApiConnectionMethod = 'GET' | 'POST' | 'PATCH' | 'PUT' | 'DELETE';
 export interface ApiConnection {
     id: string;
     name: string;
-    baseUrl: string;
+    apiUrl: string;
     method: ApiConnectionMethod;
     projectId: string;
     createdAt: Date;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "streamby-core",
-  "version": "0.26.0",
+  "version": "0.26.2",
   "description": "StreamBy middleware framework for media storage management",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",