streamby-core 0.24.1 → 0.24.3

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

@@ -9,9 +9,9 @@ export declare const createSQLRawExportTable: (connection: Pool, projectId: stri
     exportId: string;
 }>;
 export declare const sqlAdapter: {
-    find: (connection: Pool, tableName: string, filter: any) => Promise<any[]>;
+    find: (connection: Pool, tableName: string, filter: any, schema?: string) => Promise<any[]>;
     findOne: (connection: Pool, tableName: string, filter: any, schema?: string) => Promise<any | null>;
-    create: (connection: Pool, tableName: string, data: any) => Promise<any>;
-    update: (connection: Pool, tableName: string, filter: any, data: any) => Promise<any | null>;
-    delete: (connection: Pool, tableName: string, filter: any) => Promise<number>;
+    create: (connection: Pool, tableName: string, data: any, schema?: string) => Promise<any>;
+    update: (connection: Pool, tableName: string, filter: any, data: any, schema?: string) => Promise<any | null>;
+    delete: (connection: Pool, tableName: string, filter: any, schema?: string) => Promise<number>;
 };

package/dist/adapters/database/sql.js

@@ -44,12 +44,13 @@ const createSQLRawExportTable = async (connection, projectId, exportName, jsonDa
 };
 exports.createSQLRawExportTable = createSQLRawExportTable;
 exports.sqlAdapter = {
-    find: async (connection, tableName, filter) => {
+    find: async (connection, tableName, filter, schema) => {
         const keys = Object.keys(filter);
         const values = Object.values(filter);
-        let query = `SELECT * FROM "${tableName}"`;
+        const fullTableName = schema ? `"${schema}"."${tableName}"` : `"${tableName}"`;
+        let query = `SELECT * FROM ${fullTableName}`;
         if (keys.length > 0) {
-            const where = keys.map((key, i) => `"${key}" = $${i + 1}`).join(' AND ');
+            const where = keys.map((key, i) => `"${key}" = ${i + 1}`).join(' AND ');
             query += ` WHERE ${where}`;
         }
         const result = await connection.query(query, values);
@@ -63,27 +64,30 @@ exports.sqlAdapter = {
         const result = await connection.query(`SELECT * FROM ${fullTableName} WHERE ${where} LIMIT 1`, values);
         return result.rows[0] || null;
     },
-    create: async (connection, tableName, data) => {
+    create: async (connection, tableName, data, schema) => {
         const keys = Object.keys(data).map(key => `"${key}"`).join(', ');
         const values = Object.values(data);
-        const placeholders = values.map((_, i) => `$${i + 1}`).join(', ');
-        const result = await connection.query(`INSERT INTO "${tableName}" (${keys}) VALUES (${placeholders}) RETURNING *`, values);
+        const placeholders = values.map((_, i) => `${i + 1}`).join(', ');
+        const fullTableName = schema ? `"${schema}"."${tableName}"` : `"${tableName}"`;
+        const result = await connection.query(`INSERT INTO ${fullTableName} (${keys}) VALUES (${placeholders}) RETURNING *`, values);
         return result.rows[0];
     },
-    update: async (connection, tableName, filter, data) => {
+    update: async (connection, tableName, filter, data, schema) => {
         const dataKeys = Object.keys(data);
         const filterKeys = Object.keys(filter);
         const values = [...Object.values(data), ...Object.values(filter)];
-        const setClause = dataKeys.map((key, i) => `"${key}" = $${i + 1}`).join(', ');
-        const whereClause = filterKeys.map((key, i) => `"${key}" = $${dataKeys.length + i + 1}`).join(' AND ');
-        const result = await connection.query(`UPDATE "${tableName}" SET ${setClause} WHERE ${whereClause} RETURNING *`, values);
+        const setClause = dataKeys.map((key, i) => `"${key}" = ${i + 1}`).join(', ');
+        const whereClause = filterKeys.map((key, i) => `"${key}" = ${dataKeys.length + i + 1}`).join(' AND ');
+        const fullTableName = schema ? `"${schema}"."${tableName}"` : `"${tableName}"`;
+        const result = await connection.query(`UPDATE ${fullTableName} SET ${setClause} WHERE ${whereClause} RETURNING *`, values);
         return result.rows[0] || null;
     },
-    delete: async (connection, tableName, filter) => {
+    delete: async (connection, tableName, filter, schema) => {
         const keys = Object.keys(filter);
         const values = Object.values(filter);
-        const where = keys.map((key, i) => `"${key}" = $${i + 1}`).join(' AND ');
-        const result = await connection.query(`DELETE FROM "${tableName}" WHERE ${where}`, values);
+        const where = keys.map((key, i) => `"${key}" = ${i + 1}`).join(' AND ');
+        const fullTableName = schema ? `"${schema}"."${tableName}"` : `"${tableName}"`;
+        const result = await connection.query(`DELETE FROM ${fullTableName} WHERE ${where}`, values);
         return result.rowCount || 0;
     },
 };

package/dist/middleware/createRouter.js

@@ -20,11 +20,13 @@ function createStreamByRouter(config) {
     const adapter = config.adapter || (0, storage_1.createStorageProvider)(config.storageProviders);
     if (config.databases) {
         const allDbIds = config.databases.map(db => db.id);
-        (0, manager_1.registerModel)('projects', allDbIds, 'projects');
-        (0, manager_1.registerModel)('exports', allDbIds, 'exports');
+        const sqlDbs = config.databases.filter(db => db.type === 'sql');
+        const streambySchema = sqlDbs.length > 0 ? 'streamby' : undefined;
+        (0, manager_1.registerModel)('projects', allDbIds, 'projects', streambySchema);
+        (0, manager_1.registerModel)('exports', allDbIds, 'exports', streambySchema);
         const mainDb = config.databases.find(db => db.main);
         if (mainDb) {
-            (0, manager_1.registerModel)('users', [mainDb.id], 'users');
+            (0, manager_1.registerModel)('users', [mainDb.id], 'users', 'accounts');
         }
     }
     router.use((0, auth_2.authenticate)(config));

package/dist/middleware/routes/project.js

@@ -58,7 +58,7 @@ function projectRouter(config) {
                 return res.status(500).json({ message: 'Main database not configured' });
             }
             const userDbType = mainDb.type;
-            const User = (0, manager_1.getModel)('users', userDbType, 'accounts');
+            const User = (0, manager_1.getModel)('users', userDbType);
             const user = await User.findOne({ _id: auth.userId });
             if (!user) {
                 return res.status(404).json({ message: 'User not found' });
@@ -249,7 +249,7 @@ function projectRouter(config) {
                 return res.status(500).json({ message: 'Main database not configured' });
             }
             const userDbType = mainDb.type;
-            const User = (0, manager_1.getModel)('users', userDbType, 'accounts');
+            const User = (0, manager_1.getModel)('users', userDbType);
             const membersWithUsernames = await Promise.all(project.members.map(async (member) => {
                 const user = await User.findOne({ _id: member.userId });
                 return {

package/dist/models/Model.js

@@ -23,7 +23,7 @@ class Model {
             const connection = (0, connectionManager_1.getConnection)(id);
             return connection.type === dbType;
         });
-        return new Model(filteredConnectionIds, this.tableName);
+        return new Model(filteredConnectionIds, this.tableName, this.schema);
     }
     async find(filter) {
         const allResults = [];
@@ -42,10 +42,11 @@ class Model {
                 if (this.tableName === 'projects' && processedFilter.members && processedFilter.members.$elemMatch) {
                     // 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.archived as memberArchived
-            FROM "projects" p
-            JOIN "project_members" pm ON p.id = pm."projectId"
+            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]);
@@ -60,13 +61,13 @@ class Model {
                 }
                 else {
                     // General SQL find
-                    sqlResults = await sql_1.sqlAdapter.find(connection, this.tableName, processedFilter);
+                    sqlResults = await sql_1.sqlAdapter.find(connection, this.tableName, processedFilter, this.schema);
                 }
                 for (const item of sqlResults) {
                     const transformedItem = this.transformResult(item);
                     if (this.tableName === 'projects' && !transformedItem.members) {
                         // For projects, if members not already populated by join, fetch from project_members table
-                        const projectMembers = await sql_1.sqlAdapter.find(connection, 'project_members', { projectId: transformedItem.id });
+                        const projectMembers = await sql_1.sqlAdapter.find(connection, 'project_members', { projectId: transformedItem.id }, this.schema);
                         transformedItem.members = projectMembers.map((member) => ({
                             userId: member.userId,
                             role: member.role, // Assuming role is also stored in project_members
@@ -106,7 +107,7 @@ class Model {
                 }
                 // Special handling for 'users' table with raw query
                 if (this.tableName === 'users' && processedFilter.id) {
-                    const schema = this.schema || 'public'; // Default to 'public' if schema not provided
+                    const schema = this.schema || 'streamby'; // Default to 'streamby' if schema not provided
                     const query = `SELECT * FROM "${schema}"."${this.tableName}" WHERE "id" = $1::uuid LIMIT 1`;
                     const result = await connection.query(query, [processedFilter.id]);
                     return result.rows[0] || null;
@@ -116,7 +117,7 @@ class Model {
                     const transformedResult = this.transformResult(result);
                     if (this.tableName === 'projects') {
                         // For projects, fetch members from project_members table
-                        const projectMembers = await sql_1.sqlAdapter.find(connection, 'project_members', { projectId: transformedResult.id });
+                        const projectMembers = await sql_1.sqlAdapter.find(connection, 'project_members', { projectId: transformedResult.id }, this.schema);
                         transformedResult.members = projectMembers.map((member) => ({
                             userId: member.userId,
                             role: member.role, // Assuming role is also stored in project_members
@@ -171,7 +172,7 @@ class Model {
                     dataToInsert[key] = data[key];
                 }
             }
-            const created = await sql_1.sqlAdapter.create(connection, this.tableName, dataToInsert);
+            const created = await sql_1.sqlAdapter.create(connection, this.tableName, dataToInsert, this.schema);
             // Insert members into project_members table for SQL
             if (this.tableName === 'projects' && membersToInsert.length > 0) {
                 for (const member of membersToInsert) {
@@ -180,7 +181,7 @@ class Model {
                         userId: member.userId,
                         role: member.role,
                         archived: member.archived || false,
-                    });
+                    }, this.schema);
                 }
             }
             return created;
@@ -236,7 +237,7 @@ class Model {
             if (dbType === 'sql') {
                 // For SQL, directly update the project_members table
                 const memberUpdateResult = await sql_1.sqlAdapter.update(connection, 'project_members', { projectId: originalProjectId, userId: userIdToUpdate }, // originalProjectId is fine for SQL
-                { archived: newArchivedStatus, archivedBy: archivedBy, archivedAt: archivedAt });
+                { archived: newArchivedStatus, archivedBy: archivedBy, archivedAt: archivedAt }, this.schema);
                 // After updating the member, fetch the full project to return
                 if (memberUpdateResult) {
                     const updatedProject = await this.findOne({ _id: originalProjectId });
@@ -267,7 +268,7 @@ class Model {
             // General update logic
             // Use the correctly constructed updateFilter
             if (dbType === 'sql') {
-                const result = await sql_1.sqlAdapter.update(connection, this.tableName, updateFilter, data);
+                const result = await sql_1.sqlAdapter.update(connection, this.tableName, updateFilter, data, this.schema);
                 if (result)
                     return result;
             }
@@ -293,7 +294,7 @@ class Model {
                     delete processedFilter._id;
                 }
                 console.log(`SQL: Deleting from ${this.tableName} with filter:`, processedFilter);
-                const count = await sql_1.sqlAdapter.delete(connection, this.tableName, processedFilter);
+                const count = await sql_1.sqlAdapter.delete(connection, this.tableName, processedFilter, this.schema);
                 console.log(`SQL: Deleted ${count} rows from ${this.tableName}`);
                 deletedCount += count;
             }

package/dist/models/register.d.ts

@@ -1 +1 @@
-export declare const registerModel: (name: string, connectionIds: string[], tableName: string) => void;
+export declare const registerModel: (name: string, connectionIds: string[], tableName: string, schema?: string) => void;

package/dist/models/register.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.registerModel = void 0;
 const registry_1 = require("./registry");
-const registerModel = (name, connectionIds, tableName) => {
-    (0, registry_1.defineModel)(name, connectionIds, tableName);
+const registerModel = (name, connectionIds, tableName, schema) => {
+    (0, registry_1.defineModel)(name, connectionIds, tableName, schema);
 };
 exports.registerModel = registerModel;

package/dist/models/registry.d.ts

@@ -1,3 +1,3 @@
 import { Model } from './Model';
 export declare const defineModel: (name: string, connectionIds: string[], tableName: string, schema?: string) => void;
-export declare const getModel: (name: string, dbType?: string, schema?: string) => Model<any>;
+export declare const getModel: (name: string, dbType?: string) => Model<any>;

package/dist/models/registry.js

@@ -7,15 +7,11 @@ const defineModel = (name, connectionIds, tableName, schema) => {
     models[name] = new Model_1.Model(connectionIds, tableName, schema);
 };
 exports.defineModel = defineModel;
-const getModel = (name, dbType, schema) => {
+const getModel = (name, dbType) => {
     const model = models[name];
     if (!model) {
         throw new Error(`Model ${name} not defined.`);
     }
-    // If a schema is provided, create a new Model instance with the specified schema
-    if (schema) {
-        return new Model_1.Model(model.getConnectionIds(), model.getTableName(), schema); // Use getters
-    }
     if (dbType) {
         return model.useDbType(dbType);
     }

package/dist/pg/setup.js

@@ -32,7 +32,7 @@ async function setupStreambyPg({ pool, schema = 'streamby', reset = false, allow
         // Read and append reset SQL if reset is true
         if (reset) {
             console.log(`[StreamByPgSetup] Resetting schema "${schema}"...`);
-            const resetSqlPath = (0, node_path_1.join)(__dirname, '../../sql/reset.sql');
+            const resetSqlPath = (0, node_path_1.join)(process.cwd(), 'src/sql/reset.sql');
             const resetSql = await node_fs_1.promises.readFile(resetSqlPath, 'utf8');
             fullSql += resetSql;
             result.didReset = true;
@@ -46,7 +46,7 @@ async function setupStreambyPg({ pool, schema = 'streamby', reset = false, allow
         }
         // Read and append setup SQL
         console.log(`[StreamByPgSetup] Creating/updating tables and indexes in schema "${schema}"...`);
-        const setupSqlPath = (0, node_path_1.join)(__dirname, '../../sql/setup.sql');
+        const setupSqlPath = (0, node_path_1.join)(process.cwd(), 'src/sql/setup.sql');
         const setupSql = await node_fs_1.promises.readFile(setupSqlPath, 'utf8');
         fullSql += setupSql;
         result.didCreateTables = true; // Assuming if setup.sql runs, tables are handled

package/package.json

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