streamby-core 0.24.0 → 0.24.1

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

@@ -10,7 +10,7 @@ export declare const createSQLRawExportTable: (connection: Pool, projectId: stri
 }>;
 export declare const sqlAdapter: {
     find: (connection: Pool, tableName: string, filter: any) => Promise<any[]>;
-    findOne: (connection: Pool, tableName: string, filter: any) => Promise<any | null>;
+    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>;

package/dist/adapters/database/sql.js

@@ -55,11 +55,12 @@ exports.sqlAdapter = {
         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) => {

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);
+            const User = (0, manager_1.getModel)('users', userDbType, 'accounts');
             const user = await User.findOne({ _id: auth.userId });
             if (!user) {
                 return res.status(404).json({ message: 'User not found' });
@@ -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 });
         }
     });
@@ -248,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);
+            const User = (0, manager_1.getModel)('users', userDbType, 'accounts');
             const membersWithUsernames = await Promise.all(project.members.map(async (member) => {
                 const user = await User.findOne({ _id: member.userId });
                 return {

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 => {
@@ -96,7 +104,14 @@ 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 || 'public'; // Default to 'public' 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') {

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 getModel: (name: string, dbType?: string) => Model<any>;
+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>;

package/dist/models/registry.js

@@ -3,15 +3,19 @@ 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) => {
+const getModel = (name, dbType, schema) => {
     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/package.json

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