streamby-core 0.20.2 → 0.21.1

package/dist/models/Model.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Model = void 0;
 const connectionManager_1 = require("../adapters/database/connectionManager");
-const pg_1 = require("pg");
 const mongodb_1 = require("mongodb");
 const sql_1 = require("../adapters/database/sql");
 const nosql_1 = require("../adapters/database/nosql");
@@ -15,15 +14,55 @@ class Model {
         const allResults = [];
         const activeConnectionIds = this.connectionIds.filter(id => (0, connectionManager_1.getConnectedIds)().includes(id));
         for (const connectionId of activeConnectionIds) {
-            const connection = (0, connectionManager_1.getConnection)(connectionId);
-            if (connection instanceof pg_1.Pool) {
-                const sqlResults = await sql_1.sqlAdapter.find(connection, this.tableName, filter);
+            const clientEntry = (0, connectionManager_1.getConnection)(connectionId);
+            const connection = clientEntry.client;
+            const dbType = clientEntry.type;
+            let processedFilter = { ...filter };
+            if (dbType === 'sql') {
+                if (processedFilter._id) {
+                    processedFilter.id = processedFilter._id;
+                    delete processedFilter._id;
+                }
+                let sqlResults = [];
+                if (this.tableName === 'projects' && processedFilter.members && processedFilter.members.$elemMatch) {
+                    // Handle members filter for SQL projects
+                    const userId = processedFilter.members.$elemMatch.userId;
+                    const query = `
+            SELECT p.*, pm."userId" as memberUserId, pm.archived as memberArchived
+            FROM "projects" p
+            JOIN "project_members" pm ON p.id = pm."projectId"
+            WHERE pm."userId" = $1
+          `;
+                    const result = await connection.query(query, [userId]);
+                    sqlResults = result.rows.map(row => ({
+                        ...row,
+                        members: [{
+                                userId: row.memberUserId,
+                                archived: row.memberArchived,
+                                // Add other member fields if necessary
+                            }]
+                    }));
+                }
+                else {
+                    // General SQL find
+                    sqlResults = await sql_1.sqlAdapter.find(connection, this.tableName, processedFilter);
+                }
                 for (const item of sqlResults) {
-                    allResults.push(this.transformResult(item));
+                    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 });
+                        transformedItem.members = projectMembers.map((member) => ({
+                            userId: member.userId,
+                            role: member.role, // Assuming role is also stored in project_members
+                            archived: member.archived,
+                        }));
+                    }
+                    allResults.push(transformedItem);
                 }
             }
-            else if (connection instanceof mongodb_1.MongoClient) {
-                const nosqlResults = await nosql_1.nosqlAdapter.find(connection, this.tableName, filter);
+            else if (dbType === 'nosql') {
+                const nosqlResults = await nosql_1.nosqlAdapter.find(connection, this.tableName, processedFilter);
                 for (const item of nosqlResults) {
                     allResults.push(this.transformResult(item));
                 }
@@ -41,18 +80,41 @@ class Model {
     async findOne(filter) {
         const activeConnectionIds = this.connectionIds.filter(id => (0, connectionManager_1.getConnectedIds)().includes(id));
         for (const connectionId of activeConnectionIds) {
-            const connection = (0, connectionManager_1.getConnection)(connectionId);
+            const clientEntry = (0, connectionManager_1.getConnection)(connectionId);
+            const connection = clientEntry.client;
+            const dbType = clientEntry.type;
             let processedFilter = { ...filter };
-            if (connection instanceof pg_1.Pool) {
+            if (dbType === 'sql') {
                 if (processedFilter._id) {
                     processedFilter.id = processedFilter._id;
                     delete processedFilter._id;
                 }
                 const result = await sql_1.sqlAdapter.findOne(connection, this.tableName, processedFilter);
-                if (result)
-                    return result;
+                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 });
+                        transformedResult.members = projectMembers.map((member) => ({
+                            userId: member.userId,
+                            role: member.role, // Assuming role is also stored in project_members
+                            archived: member.archived,
+                        }));
+                    }
+                    return transformedResult;
+                }
             }
-            else if (connection instanceof mongodb_1.MongoClient) {
+            else if (dbType === 'nosql') {
+                if (processedFilter._id && typeof processedFilter._id === 'string') {
+                    try {
+                        processedFilter._id = new mongodb_1.ObjectId(processedFilter._id);
+                    }
+                    catch (e) {
+                        // If it's not a valid ObjectId string, it might be a UUID from a SQL project.
+                        // In this case, this NoSQL connection won't find it, so we can just continue.
+                        continue;
+                    }
+                }
                 const result = await nosql_1.nosqlAdapter.findOne(connection, this.tableName, processedFilter);
                 if (result)
                     return result;
@@ -62,12 +124,45 @@ class Model {
     }
     async create(data) {
         const activeConnectionIds = this.connectionIds.filter(id => (0, connectionManager_1.getConnectedIds)().includes(id));
-        const connection = (0, connectionManager_1.getConnection)(activeConnectionIds[0]); // Use the first active connection for creation
-        if (connection instanceof pg_1.Pool) {
-            const created = await sql_1.sqlAdapter.create(connection, this.tableName, data);
+        // Determine the target database type from the data payload
+        const targetDbType = data.dbType || 'nosql'; // Default to nosql if not specified
+        const allClientEntries = activeConnectionIds.map(id => (0, connectionManager_1.getConnection)(id));
+        // Find the connection that matches the targetDbType
+        const clientEntry = allClientEntries.find(entry => entry.type === targetDbType);
+        if (!clientEntry) {
+            throw new Error(`No active connection found for database type: ${targetDbType}`);
+        }
+        const connection = clientEntry.client;
+        const dbType = clientEntry.type;
+        if (dbType === 'sql') {
+            const dataToInsert = {};
+            let membersToInsert = [];
+            // Iterate over the keys of the incoming data
+            for (const key in data) {
+                if (this.tableName === 'projects' && key === 'members') {
+                    membersToInsert = data[key];
+                }
+                else if (this.tableName === 'projects' && key.toLowerCase() === 'dbtype') {
+                    dataToInsert["dbType"] = data[key];
+                }
+                else {
+                    dataToInsert[key] = data[key];
+                }
+            }
+            const created = await sql_1.sqlAdapter.create(connection, this.tableName, dataToInsert);
+            // Insert members into project_members table for SQL
+            if (this.tableName === 'projects' && membersToInsert.length > 0) {
+                for (const member of membersToInsert) {
+                    await sql_1.sqlAdapter.create(connection, 'project_members', {
+                        projectId: created.id,
+                        userId: member.userId,
+                        archived: member.archived || false,
+                    });
+                }
+            }
             return created;
         }
-        else if (connection instanceof mongodb_1.MongoClient) {
+        else if (dbType === 'nosql') {
             const created = await nosql_1.nosqlAdapter.create(connection, this.tableName, data);
             return created;
         }
@@ -76,7 +171,9 @@ class Model {
     async update(filter, data) {
         const activeConnectionIds = this.connectionIds.filter(id => (0, connectionManager_1.getConnectedIds)().includes(id));
         for (const connectionId of activeConnectionIds) {
-            const connection = (0, connectionManager_1.getConnection)(connectionId);
+            const clientEntry = (0, connectionManager_1.getConnection)(connectionId);
+            const connection = clientEntry.client;
+            const dbType = clientEntry.type;
             let processedFilter = { ...filter };
             // Handle specific member archiving/unarchiving
             if (data["members.$.archived"] !== undefined && processedFilter["_id"] && processedFilter["members.userId"]) {
@@ -85,25 +182,45 @@ class Model {
                 const newArchivedStatus = data["members.$.archived"];
                 const archivedBy = data["members.$.archivedBy"];
                 const archivedAt = data["members.$.archivedAt"];
-                // Fetch the project to modify its members array
-                const projectToUpdate = await this.findOne({ _id: projectId });
-                if (!projectToUpdate || !projectToUpdate.members) {
-                    continue; // Project not found or has no members, try next connection
-                }
-                const updatedMembers = projectToUpdate.members.map((member) => {
-                    if (member.userId === userIdToUpdate) {
-                        return { ...member, archived: newArchivedStatus, archivedBy: archivedBy, archivedAt: archivedAt };
+                if (dbType === 'sql') {
+                    // For SQL, directly update the project_members table
+                    const memberUpdateResult = await sql_1.sqlAdapter.update(connection, 'project_members', { projectId: projectId, userId: userIdToUpdate }, { archived: newArchivedStatus, archivedBy: archivedBy, archivedAt: archivedAt });
+                    // After updating the member, fetch the full project to return
+                    if (memberUpdateResult) {
+                        const updatedProject = await this.findOne({ _id: projectId });
+                        return updatedProject;
                     }
-                    return member;
-                });
-                // Update the project with the modified members array
-                const result = await (connection instanceof pg_1.Pool ? sql_1.sqlAdapter.update(connection, this.tableName, { id: projectId }, { members: updatedMembers }) : nosql_1.nosqlAdapter.update(connection, this.tableName, { _id: new mongodb_1.ObjectId(projectId) }, { members: updatedMembers }));
-                if (result)
-                    return result;
+                }
+                else if (dbType === 'nosql') {
+                    // For NoSQL, fetch the project to modify its members array
+                    const projectToUpdate = await this.findOne({ _id: projectId });
+                    if (!projectToUpdate || !projectToUpdate.members) {
+                        continue; // Project not found or has no members, try next connection
+                    }
+                    const updatedMembers = projectToUpdate.members.map((member) => {
+                        if (member.userId === userIdToUpdate) {
+                            return { ...member, archived: newArchivedStatus, archivedBy: archivedBy, archivedAt: archivedAt };
+                        }
+                        return member;
+                    });
+                    let objectIdProjectId;
+                    try {
+                        objectIdProjectId = new mongodb_1.ObjectId(projectId);
+                    }
+                    catch (e) {
+                        // If it's not a valid ObjectId string, it might be a UUID from a SQL project.
+                        // In this case, this NoSQL connection won't find it, so we can just continue.
+                        continue;
+                    }
+                    // Update the project with the modified members array
+                    const result = await nosql_1.nosqlAdapter.update(connection, this.tableName, { _id: objectIdProjectId }, { members: updatedMembers });
+                    if (result)
+                        return result;
+                }
             }
             else {
                 // General update logic
-                if (connection instanceof pg_1.Pool) {
+                if (dbType === 'sql') {
                     if (processedFilter._id) {
                         processedFilter.id = processedFilter._id;
                         delete processedFilter._id;
@@ -112,7 +229,7 @@ class Model {
                     if (result)
                         return result;
                 }
-                else if (connection instanceof mongodb_1.MongoClient) {
+                else if (dbType === 'nosql') {
                     const result = await nosql_1.nosqlAdapter.update(connection, this.tableName, processedFilter, data);
                     if (result)
                         return result;
@@ -125,17 +242,31 @@ class Model {
         let deletedCount = 0;
         const activeConnectionIds = this.connectionIds.filter(id => (0, connectionManager_1.getConnectedIds)().includes(id));
         for (const connectionId of activeConnectionIds) {
-            const connection = (0, connectionManager_1.getConnection)(connectionId);
+            const clientEntry = (0, connectionManager_1.getConnection)(connectionId);
+            const connection = clientEntry.client;
+            const dbType = clientEntry.type;
             let processedFilter = { ...filter };
-            if (connection instanceof pg_1.Pool) {
+            if (dbType === 'sql') {
                 if (processedFilter._id) {
                     processedFilter.id = processedFilter._id;
                     delete processedFilter._id;
                 }
+                console.log(`SQL: Deleting from ${this.tableName} with filter:`, processedFilter);
                 const count = await sql_1.sqlAdapter.delete(connection, this.tableName, processedFilter);
+                console.log(`SQL: Deleted ${count} rows from ${this.tableName}`);
                 deletedCount += count;
             }
-            else if (connection instanceof mongodb_1.MongoClient) {
+            else if (dbType === 'nosql') {
+                if (processedFilter._id && typeof processedFilter._id === 'string') {
+                    try {
+                        processedFilter._id = new mongodb_1.ObjectId(processedFilter._id);
+                    }
+                    catch (e) {
+                        // If it's not a valid ObjectId string, it might be a UUID from a SQL project.
+                        // In this case, this NoSQL connection won't find it, so we can just continue.
+                        continue;
+                    }
+                }
                 const count = await nosql_1.nosqlAdapter.delete(connection, this.tableName, processedFilter);
                 deletedCount += count;
             }

package/dist/services/auth.d.ts

@@ -1,4 +1,2 @@
-import { Request } from 'express';
-import { StreamByConfig, AuthContext } from '../types';
-export declare function resolveAuth(config: StreamByConfig, req: Request): Promise<AuthContext>;
+import { AuthContext } from '../types';
 export declare function checkRole(auth: AuthContext, required: 'viewer' | 'editor' | 'admin'): void;

package/dist/services/auth.js

@@ -1,16 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveAuth = resolveAuth;
 exports.checkRole = checkRole;
-async function resolveAuth(config, req) {
-    const auth = await config.authProvider(req);
-    if (!auth ||
-        !auth.userId ||
-        !auth.role) {
-        throw new Error('Invalid or missing authentication context');
-    }
-    return auth;
-}
 function checkRole(auth, required) {
     const roles = ['viewer', 'editor', 'admin'];
     const userIdx = roles.indexOf(auth.role);

package/dist/types/index.d.ts

@@ -61,10 +61,9 @@ export interface StreamByConfig {
     adapter?: StorageAdapter;
 }
 export interface AuthContext {
-    role: 'viewer' | 'editor' | 'admin';
     userId: string;
     username: string;
-    profilePic?: string;
+    role: 'viewer' | 'editor' | 'admin';
 }
 export type AuthProvider = (req: Request) => Promise<AuthContext>;
 export interface Export {

package/package.json

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

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

@@ -1,8 +0,0 @@
-import { MongoClient, Document } from 'mongodb';
-export declare const nosqlAdapter: {
-    find: <T extends Document>(connection: MongoClient, tableName: string, filter: any) => Promise<T[]>;
-    findOne: <T extends Document>(connection: MongoClient, tableName: string, filter: any) => Promise<T | null>;
-    create: <T extends Document>(connection: MongoClient, tableName: string, data: T) => Promise<T>;
-    update: <T extends Document>(connection: MongoClient, tableName: string, filter: any, data: Partial<T>) => Promise<number>;
-    delete: <T extends Document>(connection: MongoClient, tableName: string, filter: any) => Promise<number>;
-};

package/dist/adapters/database/nosqlAdapter.js

@@ -1,30 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.nosqlAdapter = void 0;
-exports.nosqlAdapter = {
-    find: async (connection, tableName, filter) => {
-        const db = connection.db();
-        const result = await db.collection(tableName).find(filter).toArray();
-        return result;
-    },
-    findOne: async (connection, tableName, filter) => {
-        const db = connection.db();
-        const result = await db.collection(tableName).findOne(filter);
-        return result;
-    },
-    create: async (connection, tableName, data) => {
-        const db = connection.db();
-        const result = await db.collection(tableName).insertOne(data);
-        return { ...data, _id: result.insertedId };
-    },
-    update: async (connection, tableName, filter, data) => {
-        const db = connection.db();
-        const result = await db.collection(tableName).updateMany(filter, { $set: data });
-        return result.modifiedCount;
-    },
-    delete: async (connection, tableName, filter) => {
-        const db = connection.db();
-        const result = await db.collection(tableName).deleteMany(filter);
-        return result.deletedCount;
-    },
-};

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

@@ -1,8 +0,0 @@
-import { Pool } from 'pg';
-export declare const sqlAdapter: {
-    find: <T>(connection: Pool, tableName: string, filter: any) => Promise<T[]>;
-    findOne: <T>(connection: Pool, tableName: string, filter: any) => Promise<T | null>;
-    create: <T>(connection: Pool, tableName: string, data: T) => Promise<T>;
-    update: <T>(connection: Pool, tableName: string, filter: any, data: Partial<T>) => Promise<number>;
-    delete: (connection: Pool, tableName: string, filter: any) => Promise<number>;
-};

package/dist/adapters/database/sqlAdapter.js

@@ -1,42 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.sqlAdapter = void 0;
-exports.sqlAdapter = {
-    find: async (connection, tableName, filter) => {
-        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}`, values);
-        return result.rows;
-    },
-    findOne: async (connection, tableName, filter) => {
-        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);
-        return result.rows[0] || null;
-    },
-    create: async (connection, tableName, data) => {
-        const keys = Object.keys(data).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);
-        return result.rows[0];
-    },
-    update: async (connection, tableName, filter, data) => {
-        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}`, values);
-        return result.rowCount || 0;
-    },
-    delete: async (connection, tableName, filter) => {
-        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);
-        return result.rowCount || 0;
-    },
-};

package/dist/adapters/gcs.js

@@ -1 +0,0 @@
-"use strict";

package/dist/adapters/local.js

@@ -1 +0,0 @@
-"use strict";

package/dist/adapters/s3.d.ts

@@ -1,11 +0,0 @@
-import { S3Config, StorageAdapter } from '../types';
-export declare class S3Adapter implements StorageAdapter {
-    private s3;
-    private bucket;
-    constructor(config: S3Config);
-    listFiles(projectId: string): Promise<any[]>;
-    deleteProjectImage(projectId: string): Promise<any>;
-    deleteProjectDirectory(projectId: string): Promise<any>;
-    getPresignedUrl(contentType: string, projectId: string): Promise<any>;
-    getPresignedProjectImageUrl(projectId: string): Promise<any>;
-}

package/dist/adapters/s3.js

@@ -1,65 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.S3Adapter = void 0;
-const client_s3_1 = require("@aws-sdk/client-s3");
-const s3_request_presigner_1 = require("@aws-sdk/s3-request-presigner");
-class S3Adapter {
-    constructor(config) {
-        this.s3 = new client_s3_1.S3Client({
-            region: config.region,
-            credentials: {
-                accessKeyId: config.accessKeyId,
-                secretAccessKey: config.secretAccessKey,
-            },
-        });
-        this.bucket = config.bucket;
-    }
-    async listFiles(projectId) {
-        const command = new client_s3_1.ListObjectsV2Command({
-            Bucket: this.bucket,
-            Prefix: `${projectId}/`,
-        });
-        const result = await this.s3.send(command);
-        return result.Contents || [];
-    }
-    async deleteProjectImage(projectId) {
-        const command = new client_s3_1.DeleteObjectCommand({
-            Bucket: this.bucket,
-            Key: `${projectId}/project-image`,
-        });
-        return await this.s3.send(command);
-    }
-    async deleteProjectDirectory(projectId) {
-        const listCommand = new client_s3_1.ListObjectsV2Command({
-            Bucket: this.bucket,
-            Prefix: `${projectId}/`,
-        });
-        const listedObjects = await this.s3.send(listCommand);
-        if (!listedObjects.Contents || listedObjects.Contents.length === 0) {
-            return;
-        }
-        const deleteParams = {
-            Bucket: this.bucket,
-            Delete: { Objects: listedObjects.Contents.map(({ Key }) => ({ Key })) },
-        };
-        const deleteCommand = new client_s3_1.DeleteObjectCommand(deleteParams);
-        return await this.s3.send(deleteCommand);
-    }
-    async getPresignedUrl(contentType, projectId) {
-        const command = new client_s3_1.PutObjectCommand({
-            Bucket: this.bucket,
-            Key: `${projectId}/${Date.now()}`,
-            ContentType: contentType,
-        });
-        return await (0, s3_request_presigner_1.getSignedUrl)(this.s3, command, { expiresIn: 3600 });
-    }
-    async getPresignedProjectImageUrl(projectId) {
-        const command = new client_s3_1.PutObjectCommand({
-            Bucket: this.bucket,
-            Key: `${projectId}/project-image`,
-            ContentType: 'image/jpeg',
-        });
-        return await (0, s3_request_presigner_1.getSignedUrl)(this.s3, command, { expiresIn: 3600 });
-    }
-}
-exports.S3Adapter = S3Adapter;

package/dist/database/Model.d.ts

@@ -1,11 +0,0 @@
-import { Document } from 'mongodb';
-export declare class Model<T extends Document> {
-    private connectionId;
-    private tableName;
-    constructor(connectionId: string, tableName: string);
-    find(filter: any): Promise<T[]>;
-    findOne(filter: any): Promise<T | null>;
-    create(data: T): Promise<T>;
-    update(filter: any, data: Partial<T>): Promise<number>;
-    delete(filter: any): Promise<number>;
-}

package/dist/database/Model.js

@@ -1,95 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Model = void 0;
-const connectionManager_1 = require("./connectionManager");
-const pg_1 = require("pg");
-const mongodb_1 = require("mongodb");
-class Model {
-    constructor(connectionId, tableName) {
-        this.connectionId = connectionId;
-        this.tableName = tableName;
-    }
-    async find(filter) {
-        const connection = (0, connectionManager_1.getConnection)(this.connectionId);
-        if (connection instanceof pg_1.Pool) {
-            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 "${this.tableName}" WHERE ${where}`, values);
-            return result.rows;
-        }
-        else if (connection instanceof mongodb_1.MongoClient) {
-            const db = connection.db();
-            const result = await db.collection(this.tableName).find(filter).toArray();
-            return result;
-        }
-        return [];
-    }
-    async findOne(filter) {
-        const connection = (0, connectionManager_1.getConnection)(this.connectionId);
-        if (connection instanceof pg_1.Pool) {
-            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 "${this.tableName}" WHERE ${where} LIMIT 1`, values);
-            return result.rows[0] || null;
-        }
-        else if (connection instanceof mongodb_1.MongoClient) {
-            const db = connection.db();
-            const result = await db.collection(this.tableName).findOne(filter);
-            return result;
-        }
-        return null;
-    }
-    async create(data) {
-        const connection = (0, connectionManager_1.getConnection)(this.connectionId);
-        if (connection instanceof pg_1.Pool) {
-            const keys = Object.keys(data).join(', ');
-            const values = Object.values(data);
-            const placeholders = values.map((_, i) => `$${i + 1}`).join(', ');
-            const result = await connection.query(`INSERT INTO "${this.tableName}" (${keys}) VALUES (${placeholders}) RETURNING *`, values);
-            return result.rows[0];
-        }
-        else if (connection instanceof mongodb_1.MongoClient) {
-            const db = connection.db();
-            const result = await db.collection(this.tableName).insertOne(data);
-            return { ...data, _id: result.insertedId };
-        }
-        return data;
-    }
-    async update(filter, data) {
-        const connection = (0, connectionManager_1.getConnection)(this.connectionId);
-        if (connection instanceof pg_1.Pool) {
-            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 "${this.tableName}" SET ${setClause} WHERE ${whereClause}`, values);
-            return result.rowCount || 0;
-        }
-        else if (connection instanceof mongodb_1.MongoClient) {
-            const db = connection.db();
-            const result = await db.collection(this.tableName).updateMany(filter, { $set: data });
-            return result.modifiedCount;
-        }
-        return 0;
-    }
-    async delete(filter) {
-        const connection = (0, connectionManager_1.getConnection)(this.connectionId);
-        if (connection instanceof pg_1.Pool) {
-            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 "${this.tableName}" WHERE ${where}`, values);
-            return result.rowCount || 0;
-        }
-        else if (connection instanceof mongodb_1.MongoClient) {
-            const db = connection.db();
-            const result = await db.collection(this.tableName).deleteMany(filter);
-            return result.deletedCount;
-        }
-        return 0;
-    }
-}
-exports.Model = Model;

package/dist/database/connectionManager.d.ts

@@ -1,5 +0,0 @@
-import { Pool } from 'pg';
-import { MongoClient } from 'mongodb';
-import { DatabaseCredential } from '../types';
-export declare const initConnections: (configs: DatabaseCredential[]) => Promise<void>;
-export declare const getConnection: (id: string) => Pool | MongoClient;