streamby-core 0.24.0 → 0.24.2

package/dist/adapters/database/connectionManager.js

@@ -44,8 +44,9 @@ exports.getConnection = getConnection;
 const ensureTablesExist = async (pool) => {
     try {
         await pool.query(`
+      CREATE SCHEMA IF NOT EXISTS streamby;
       CREATE EXTENSION IF NOT EXISTS "uuid-ossp";
-      CREATE TABLE IF NOT EXISTS projects (
+      CREATE TABLE IF NOT EXISTS streamby.projects (
         id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
         name VARCHAR(255) NOT NULL,
         description TEXT,
@@ -57,21 +58,21 @@ const ensureTablesExist = async (pool) => {
         console.log('✅ "projects" table ensured to exist.');
         // Ensure dbType column exists and is correctly configured
         await pool.query(`
-      ALTER TABLE projects ADD COLUMN IF NOT EXISTS "dbType" VARCHAR(50);
+      ALTER TABLE streamby.projects ADD COLUMN IF NOT EXISTS "dbType" VARCHAR(50);
     `);
         await pool.query(`
-      UPDATE projects SET "dbType" = 'nosql' WHERE "dbType" IS NULL;
+      UPDATE streamby.projects SET "dbType" = 'nosql' WHERE "dbType" IS NULL;
     `);
         await pool.query(`
-      ALTER TABLE projects ALTER COLUMN "dbType" SET NOT NULL;
+      ALTER TABLE streamby.projects ALTER COLUMN "dbType" SET NOT NULL;
     `);
         await pool.query(`
-      ALTER TABLE projects ALTER COLUMN "dbType" SET DEFAULT 'nosql';
+      ALTER TABLE streamby.projects ALTER COLUMN "dbType" SET DEFAULT 'nosql';
     `);
         await pool.query(`
-      CREATE TABLE IF NOT EXISTS exports (
+      CREATE TABLE IF NOT EXISTS streamby.exports (
         id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
-        "projectId" UUID NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+        "projectId" UUID NOT NULL REFERENCES streamby.projects(id) ON DELETE CASCADE,
         status VARCHAR(50) NOT NULL DEFAULT 'pending',
         "filePath" TEXT,
         "createdAt" TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
@@ -80,9 +81,9 @@ const ensureTablesExist = async (pool) => {
     `);
         console.log('✅ "exports" table ensured to exist.');
         await pool.query(`
-      CREATE TABLE IF NOT EXISTS project_members (
+      CREATE TABLE IF NOT EXISTS streamby.project_members (
         id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
-        "projectId" UUID NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+        "projectId" UUID NOT NULL REFERENCES streamby.projects(id) ON DELETE CASCADE,
         "userId" VARCHAR(255) NOT NULL,
         role VARCHAR(255) NOT NULL DEFAULT 'member',
         archived BOOLEAN NOT NULL DEFAULT FALSE,

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[]>;
-    findOne: (connection: Pool, tableName: string, filter: any) => 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>;
+    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, 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,45 +44,50 @@ 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);
         return result.rows;
     },
-    findOne: async (connection, tableName, filter) => {
+    findOne: 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(`SELECT * FROM "${tableName}" WHERE ${where} LIMIT 1`, values);
+        const where = keys.map((key, i) => `"${key}" = ${i + 1}`).join(' AND ');
+        const fullTableName = schema ? `"${schema}"."${tableName}"` : `"${tableName}"`;
+        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', streambySchema);
         }
     }
     router.use((0, auth_2.authenticate)(config));

package/dist/middleware/routes/project.js

@@ -80,6 +80,7 @@ function projectRouter(config) {
             res.status(200).json({ success: true, projects: projects, projectId: newProject._id || newProject.id, message: 'Project created successfully' });
         }
         catch (err) {
+            console.error('Error creating project:', err);
             res.status(500).json({ message: 'Failed to create project', details: err.message });
         }
     });

package/dist/models/Model.d.ts

@@ -2,7 +2,10 @@ import { Document } from 'mongodb';
 export declare class Model<T extends Document> {
     private connectionIds;
     private tableName;
-    constructor(connectionIds: string[], tableName: string);
+    private schema?;
+    constructor(connectionIds: string[], tableName: string, schema?: string);
+    getConnectionIds(): string[];
+    getTableName(): string;
     useDbType(dbType: string): Model<T>;
     find(filter: any): Promise<T[]>;
     private transformResult;

package/dist/models/Model.js

@@ -6,9 +6,17 @@ const mongodb_1 = require("mongodb");
 const sql_1 = require("../adapters/database/sql");
 const nosql_1 = require("../adapters/database/nosql");
 class Model {
-    constructor(connectionIds, tableName) {
+    constructor(connectionIds, tableName, schema) {
         this.connectionIds = connectionIds;
         this.tableName = tableName;
+        this.schema = schema;
+    }
+    // Add these getter methods
+    getConnectionIds() {
+        return this.connectionIds;
+    }
+    getTableName() {
+        return this.tableName;
     }
     useDbType(dbType) {
         const filteredConnectionIds = this.connectionIds.filter(id => {
@@ -34,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]);
@@ -52,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
@@ -96,12 +105,19 @@ class Model {
                     processedFilter.id = processedFilter._id;
                     delete processedFilter._id;
                 }
-                const result = await sql_1.sqlAdapter.findOne(connection, this.tableName, processedFilter);
+                // Special handling for 'users' table with raw query
+                if (this.tableName === 'users' && processedFilter.id) {
+                    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;
+                }
+                const result = await sql_1.sqlAdapter.findOne(connection, this.tableName, processedFilter, this.schema); // Pass this.schema
                 if (result) {
                     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
@@ -156,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) {
@@ -165,7 +181,7 @@ class Model {
                         userId: member.userId,
                         role: member.role,
                         archived: member.archived || false,
-                    });
+                    }, this.schema);
                 }
             }
             return created;
@@ -221,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 });
@@ -252,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;
             }
@@ -278,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) => void;
+export declare const defineModel: (name: string, connectionIds: string[], tableName: string, schema?: string) => void;
 export declare const getModel: (name: string, dbType?: string) => Model<any>;

package/dist/models/registry.js

@@ -3,8 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getModel = exports.defineModel = void 0;
 const Model_1 = require("./Model");
 const models = {};
-const defineModel = (name, connectionIds, tableName) => {
-    models[name] = new Model_1.Model(connectionIds, tableName);
+const defineModel = (name, connectionIds, tableName, schema) => {
+    models[name] = new Model_1.Model(connectionIds, tableName, schema);
 };
 exports.defineModel = defineModel;
 const getModel = (name, 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.0",
+  "version": "0.24.2",
   "description": "StreamBy middleware framework for media storage management",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",