streamby-core 0.26.0 → 0.26.1

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/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/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/package.json

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