streamby-core 0.20.1 → 0.21.0

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

@@ -2,5 +2,9 @@ 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;
+export declare const getConnection: (id: string) => {
+    id: string;
+    type: "sql" | "nosql";
+    client: Pool | MongoClient;
+};
 export declare const getConnectedIds: () => string[];

package/dist/adapters/database/connectionManager.js

@@ -3,8 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getConnectedIds = exports.getConnection = exports.initConnections = void 0;
 const pg_1 = require("pg");
 const mongodb_1 = require("mongodb");
-const clients = {};
-const connectedIds = [];
+const nosql_1 = require("./nosql");
+const connectedClients = [];
 const initConnections = async (configs) => {
     for (const config of configs) {
         if (!config.connectionString) {
@@ -15,16 +15,16 @@ const initConnections = async (configs) => {
             if (config.type === 'sql') {
                 const pool = new pg_1.Pool({ connectionString: config.connectionString });
                 await pool.connect();
-                clients[config.id] = pool;
-                connectedIds.push(config.id);
+                connectedClients.push({ id: config.id, type: 'sql', client: pool });
                 console.log(`🟢 PostgreSQL connection established for ID: ${config.id}`);
+                await ensureTablesExist(pool);
             }
             else if (config.type === 'nosql') {
                 const client = new mongodb_1.MongoClient(config.connectionString);
                 await client.connect();
-                clients[config.id] = client;
-                connectedIds.push(config.id);
+                connectedClients.push({ id: config.id, type: 'nosql', client: client });
                 console.log(`🟢 MongoDB connection established for ID: ${config.id}`);
+                await (0, nosql_1.ensureCollectionsExist)(client);
             }
         }
         catch (error) {
@@ -34,14 +34,70 @@ const initConnections = async (configs) => {
 };
 exports.initConnections = initConnections;
 const getConnection = (id) => {
-    const client = clients[id];
-    if (!client) {
+    const clientEntry = connectedClients.find(c => c.id === id);
+    if (!clientEntry) {
         throw new Error(`Connection with id ${id} not found.`);
     }
-    return client;
+    return clientEntry;
 };
 exports.getConnection = getConnection;
+const ensureTablesExist = async (pool) => {
+    try {
+        await pool.query(`
+      CREATE EXTENSION IF NOT EXISTS "uuid-ossp";
+      CREATE TABLE IF NOT EXISTS projects (
+        id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+        name VARCHAR(255) NOT NULL,
+        description TEXT,
+        "createdAt" TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
+        "updatedAt" TIMESTAMP WITH TIME ZONE DEFAULT NOW()
+      );
+    `);
+        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);
+    `);
+        await pool.query(`
+      UPDATE projects SET "dbType" = 'nosql' WHERE "dbType" IS NULL;
+    `);
+        await pool.query(`
+      ALTER TABLE projects ALTER COLUMN "dbType" SET NOT NULL;
+    `);
+        await pool.query(`
+      ALTER TABLE projects ALTER COLUMN "dbType" SET DEFAULT 'nosql';
+    `);
+        await pool.query(`
+      CREATE TABLE IF NOT EXISTS exports (
+        id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+        "projectId" UUID NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+        status VARCHAR(50) NOT NULL DEFAULT 'pending',
+        "filePath" TEXT,
+        "createdAt" TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
+        "updatedAt" TIMESTAMP WITH TIME ZONE DEFAULT NOW()
+      );
+    `);
+        console.log('✅ "exports" table ensured to exist.');
+        await pool.query(`
+      CREATE TABLE IF NOT EXISTS project_members (
+        id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+        "projectId" UUID NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+        "userId" VARCHAR(255) NOT NULL,
+        archived BOOLEAN NOT NULL DEFAULT FALSE,
+        "archivedBy" VARCHAR(255),
+        "archivedAt" TIMESTAMP WITH TIME ZONE,
+        "createdAt" TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
+        "updatedAt" TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
+        UNIQUE ("projectId", "userId")
+      );
+    `);
+        console.log('✅ "project_members" table ensured to exist.');
+    }
+    catch (error) {
+        console.error('❌ Error ensuring tables exist:', error);
+    }
+};
 const getConnectedIds = () => {
-    return connectedIds;
+    return connectedClients.map(c => c.id);
 };
 exports.getConnectedIds = getConnectedIds;

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

@@ -1,4 +1,5 @@
 import { MongoClient, Document } from 'mongodb';
+export declare const ensureCollectionsExist: (client: MongoClient) => Promise<void>;
 export declare const nosqlAdapter: {
     find: (connection: MongoClient, tableName: string, filter: any) => Promise<Document[]>;
     findOne: (connection: MongoClient, tableName: string, filter: any) => Promise<Document | null>;

package/dist/adapters/database/nosql.js

@@ -1,7 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.nosqlAdapter = void 0;
+exports.nosqlAdapter = exports.ensureCollectionsExist = void 0;
 const mongodb_1 = require("mongodb");
+const ensureCollectionsExist = async (client) => {
+    const db = client.db();
+    // Ensure 'projects' collection exists and define its schema implicitly
+    // Schema: { _id: ObjectId, name: string, description: string, dbType: string, createdAt: Date, updatedAt: Date, members: [{ userId: string, archived: boolean }] }
+    const projectsCollection = db.collection('projects');
+    await projectsCollection.findOne({}); // Attempt to find one to ensure collection is created if it doesn't exist
+    console.log('✅ "projects" collection ensured to exist.');
+    // Ensure 'exports' collection exists and define its schema implicitly
+    // Schema: { _id: ObjectId, projectId: ObjectId, status: string, filePath: string, createdAt: Date, updatedAt: Date }
+    const exportsCollection = db.collection('exports');
+    await exportsCollection.findOne({}); // Attempt to find one to ensure collection is created if it doesn't exist
+    console.log('✅ "exports" collection ensured to exist.');
+};
+exports.ensureCollectionsExist = ensureCollectionsExist;
 exports.nosqlAdapter = {
     find: async (connection, tableName, filter) => {
         const db = connection.db();

package/dist/adapters/database/sql.js

@@ -5,8 +5,12 @@ 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);
+        let query = `SELECT * FROM "${tableName}"`;
+        if (keys.length > 0) {
+            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) => {
@@ -17,7 +21,7 @@ exports.sqlAdapter = {
         return result.rows[0] || null;
     },
     create: async (connection, tableName, data) => {
-        const keys = Object.keys(data).join(', ');
+        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);

package/dist/middleware/createRouter.js

@@ -10,6 +10,7 @@ const presign_1 = require("../services/presign");
 const manager_1 = require("../models/manager");
 const storage_1 = require("../providers/storage");
 const connectionManager_1 = require("../adapters/database/connectionManager");
+const auth_1 = require("../services/auth");
 function isProjectMember(project, userId) {
     return project.members?.some((m) => m.userId?.toString() === userId?.toString());
 }
@@ -18,18 +19,15 @@ function createStreamByRouter(config) {
     (0, connectionManager_1.initConnections)(config.databases || []);
     const adapter = config.adapter || (0, storage_1.createStorageProvider)(config.storageProviders);
     if (config.databases) {
-        for (const db of config.databases) {
-            if (db.type === 'sql') {
-                (0, manager_1.registerModel)('Project', [db.id], 'projects');
-                (0, manager_1.registerModel)('Export', [db.id], 'exports');
-            }
-        }
+        const allDbIds = config.databases.map(db => db.id);
+        (0, manager_1.registerModel)('projects', allDbIds, 'projects');
+        (0, manager_1.registerModel)('exports', allDbIds, 'exports');
     }
-    const Project = (0, manager_1.getModel)('Project');
-    const Export = (0, manager_1.getModel)('Export');
+    const Project = (0, manager_1.getModel)('projects');
+    const Export = (0, manager_1.getModel)('exports');
     router.get('/auth', async (req, res) => {
         try {
-            const auth = await config.authProvider(req);
+            const auth = await (0, auth_1.resolveAuth)(config, req);
             res.status(200).json({ logged: true, ...auth });
         }
         catch (err) {
@@ -104,8 +102,21 @@ function createStreamByRouter(config) {
     router.get('/projects', async (req, res) => {
         try {
             const auth = await config.authProvider(req);
-            const archived = req.query.archived ? String(req.query.archived).toLowerCase() === 'true' : undefined;
-            const projects = (await Project.find({ members: { $elemMatch: { userId: auth.userId } }, archived })).map(project => {
+            const archivedQuery = req.query.archived;
+            const filterArchived = archivedQuery !== undefined ? String(archivedQuery).toLowerCase() === 'true' : undefined;
+            const allProjects = await Project.find({}); // Fetch all projects
+            const projects = allProjects
+                .filter(project => {
+                const isMember = project.members?.some((m) => m.userId?.toString() === auth.userId?.toString());
+                if (!isMember)
+                    return false;
+                if (filterArchived !== undefined) {
+                    const currentUserMember = project.members?.find((member) => member.userId === auth.userId);
+                    return currentUserMember ? (currentUserMember.archived || false) === filterArchived : false;
+                }
+                return true;
+            })
+                .map(project => {
                 const currentUserMember = project.members?.find((member) => member.userId === auth.userId);
                 return {
                     id: project._id || project.id,
@@ -118,6 +129,7 @@ function createStreamByRouter(config) {
             res.json({ projects });
         }
         catch (err) {
+            console.error('Error in /projects endpoint:', err);
             res.status(500).json({ error: 'Failed to list projects', details: err });
         }
     });
@@ -296,7 +308,6 @@ function createStreamByRouter(config) {
                 collectionName,
                 projectId
             });
-            await Project.update({ _id: projectId }, { $push: { exports: newExport._id } });
             res.status(201).json({ data: { ...newExport, id: newExport._id || newExport.id, _id: undefined } });
         }
         catch (err) {

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

@@ -1,6 +1,6 @@
 {
   "name": "streamby-core",
-  "version": "0.20.1",
+  "version": "0.21.0",
   "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;

package/dist/database/connectionManager.js

@@ -1,32 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getConnection = exports.initConnections = void 0;
-const pg_1 = require("pg");
-const mongodb_1 = require("mongodb");
-const clients = {};
-const initConnections = async (configs) => {
-    for (const config of configs) {
-        if (!config.connectionString) {
-            throw new Error(`Connection string not provided for database config with id ${config.id}`);
-        }
-        if (config.type === 'sql') {
-            const pool = new pg_1.Pool({ connectionString: config.connectionString });
-            await pool.connect();
-            clients[config.id] = pool;
-        }
-        else if (config.type === 'nosql') {
-            const client = new mongodb_1.MongoClient(config.connectionString);
-            await client.connect();
-            clients[config.id] = client;
-        }
-    }
-};
-exports.initConnections = initConnections;
-const getConnection = (id) => {
-    const client = clients[id];
-    if (!client) {
-        throw new Error(`Connection with id ${id} not found.`);
-    }
-    return client;
-};
-exports.getConnection = getConnection;

package/dist/database/index.d.ts

@@ -1,3 +0,0 @@
-export * from './connectionManager';
-export * from './Model';
-export * from './modelRegistry';

package/dist/database/index.js

@@ -1,19 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./connectionManager"), exports);
-__exportStar(require("./Model"), exports);
-__exportStar(require("./modelRegistry"), exports);

package/dist/database/model.d.ts

@@ -1,20 +0,0 @@
-export interface BaseModel {
-    id?: string;
-}
-export interface ModelDefinition<T extends BaseModel> {
-    name: string;
-    connectionName: string;
-}
-export interface QueryOptions {
-    filter?: Record<string, any>;
-    limit?: number;
-    offset?: number;
-    sort?: Record<string, 1 | -1>;
-}
-export interface ModelOperations<T extends BaseModel> {
-    find(options?: QueryOptions): Promise<T[]>;
-    findById(id: string): Promise<T | null>;
-    create(data: Omit<T, 'id'>): Promise<T>;
-    update(id: string, data: Partial<Omit<T, 'id'>>): Promise<T | null>;
-    delete(id: string): Promise<boolean>;
-}

package/dist/database/model.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/database/modelManager.d.ts

@@ -1,8 +0,0 @@
-import { BaseModel, ModelDefinition, ModelOperations } from './model';
-declare class ModelManager {
-    private models;
-    registerModel<T extends BaseModel>(definition: ModelDefinition<T>): void;
-    getModel<T extends BaseModel>(name: string): ModelOperations<T>;
-}
-export declare const modelManager: ModelManager;
-export {};

package/dist/database/modelManager.js

@@ -1,38 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.modelManager = void 0;
-const connectionManager_1 = require("./connectionManager");
-const sqlAdapter_1 = require("./sqlAdapter");
-const mongoAdapter_1 = require("./mongoAdapter");
-const mongodb_1 = require("mongodb");
-class ModelManager {
-    constructor() {
-        this.models = new Map();
-    }
-    registerModel(definition) {
-        const client = connectionManager_1.connectionManager.getClient(definition.connectionName);
-        if (!client) {
-            throw new Error(`Connection '${definition.connectionName}' not found for model '${definition.name}'`);
-        }
-        let adapter;
-        if (client instanceof mongodb_1.Pool) {
-            adapter = new sqlAdapter_1.SqlAdapter(client, definition.name.toLowerCase() + 's'); // Assuming table name is plural of model name
-        }
-        else if (client instanceof mongodb_1.MongoClient) {
-            adapter = new mongoAdapter_1.MongoAdapter(client, definition.name.toLowerCase() + 's'); // Assuming collection name is plural of model name
-        }
-        else {
-            throw new Error(`Unsupported client type for connection '${definition.connectionName}'`);
-        }
-        this.models.set(definition.name, adapter);
-        console.log(`Model '${definition.name}' registered with connection '${definition.connectionName}'`);
-    }
-    getModel(name) {
-        const model = this.models.get(name);
-        if (!model) {
-            throw new Error(`Model '${name}' not found. Make sure it is registered.`);
-        }
-        return model;
-    }
-}
-exports.modelManager = new ModelManager();

package/dist/database/modelRegistry.d.ts

@@ -1,3 +0,0 @@
-import { Model } from './Model';
-export declare const defineModel: (name: string, connectionId: string, tableName: string) => void;
-export declare const getModel: (name: string) => Model<any>;

package/dist/database/modelRegistry.js

@@ -1,17 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getModel = exports.defineModel = void 0;
-const Model_1 = require("./Model");
-const models = {};
-const defineModel = (name, connectionId, tableName) => {
-    models[name] = new Model_1.Model(connectionId, tableName);
-};
-exports.defineModel = defineModel;
-const getModel = (name) => {
-    const model = models[name];
-    if (!model) {
-        throw new Error(`Model ${name} not defined.`);
-    }
-    return model;
-};
-exports.getModel = getModel;

package/dist/database/mongoAdapter.d.ts

@@ -1,11 +0,0 @@
-import { MongoClient } from 'mongodb';
-import { BaseModel, ModelOperations, QueryOptions } from './model';
-export declare class MongoAdapter<T extends BaseModel> implements ModelOperations<T> {
-    private collection;
-    constructor(client: MongoClient, collectionName: string);
-    find(options?: QueryOptions): Promise<T[]>;
-    findById(id: string): Promise<T | null>;
-    create(data: Omit<T, 'id'>): Promise<T>;
-    update(id: string, data: Partial<Omit<T, 'id'>>): Promise<T | null>;
-    delete(id: string): Promise<boolean>;
-}

package/dist/database/mongoAdapter.js

@@ -1,42 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MongoAdapter = void 0;
-const mongodb_1 = require("mongodb");
-class MongoAdapter {
-    constructor(client, collectionName) {
-        // Assuming a default database name for now, or it could be passed in config
-        const db = client.db();
-        this.collection = db.collection(collectionName);
-    }
-    async find(options) {
-        let cursor = this.collection.find(options?.filter || {});
-        if (options?.sort) {
-            cursor = cursor.sort(options.sort);
-        }
-        if (options?.limit) {
-            cursor = cursor.limit(options.limit);
-        }
-        if (options?.offset) {
-            cursor = cursor.skip(options.offset);
-        }
-        const result = await cursor.toArray();
-        return result.map(doc => ({ ...doc, id: doc._id?.toString() }));
-    }
-    async findById(id) {
-        const doc = await this.collection.findOne({ _id: new mongodb_1.ObjectId(id) });
-        return doc ? { ...doc, id: doc._id?.toString() } : null;
-    }
-    async create(data) {
-        const result = await this.collection.insertOne(data);
-        return { ...data, id: result.insertedId.toString() };
-    }
-    async update(id, data) {
-        const result = await this.collection.findOneAndUpdate({ _id: new mongodb_1.ObjectId(id) }, { $set: data }, { returnDocument: 'after' });
-        return result.value ? { ...result.value, id: result.value._id?.toString() } : null;
-    }
-    async delete(id) {
-        const result = await this.collection.deleteOne({ _id: new mongodb_1.ObjectId(id) });
-        return result.deletedCount > 0;
-    }
-}
-exports.MongoAdapter = MongoAdapter;

package/dist/database/sqlAdapter.d.ts

@@ -1,12 +0,0 @@
-import { Pool } from 'pg';
-import { BaseModel, ModelOperations, QueryOptions } from './model';
-export declare class SqlAdapter<T extends BaseModel> implements ModelOperations<T> {
-    private client;
-    private tableName;
-    constructor(client: Pool, tableName: string);
-    find(options?: QueryOptions): Promise<T[]>;
-    findById(id: string): Promise<T | null>;
-    create(data: Omit<T, 'id'>): Promise<T>;
-    update(id: string, data: Partial<Omit<T, 'id'>>): Promise<T | null>;
-    delete(id: string): Promise<boolean>;
-}

package/dist/database/sqlAdapter.js

@@ -1,68 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SqlAdapter = void 0;
-class SqlAdapter {
-    constructor(client, tableName) {
-        this.client = client;
-        this.tableName = tableName;
-    }
-    async find(options) {
-        let query = `SELECT * FROM ${this.tableName}`;
-        const values = [];
-        const conditions = [];
-        let paramIndex = 1;
-        if (options?.filter) {
-            for (const key in options.filter) {
-                conditions.push(`${key} = $${paramIndex++}`);
-                values.push(options.filter[key]);
-            }
-        }
-        if (conditions.length > 0) {
-            query += ` WHERE ${conditions.join(' AND ')}`;
-        }
-        if (options?.sort) {
-            const sortKeys = Object.keys(options.sort);
-            if (sortKeys.length > 0) {
-                const orderBy = sortKeys.map(key => `${key} ${options.sort[key] === 1 ? 'ASC' : 'DESC'}`).join(', ');
-                query += ` ORDER BY ${orderBy}`;
-            }
-        }
-        if (options?.limit) {
-            query += ` LIMIT $${paramIndex++}`;
-            values.push(options.limit);
-        }
-        if (options?.offset) {
-            query += ` OFFSET $${paramIndex++}`;
-            values.push(options.offset);
-        }
-        const result = await this.client.query(query, values);
-        return result.rows;
-    }
-    async findById(id) {
-        const query = `SELECT * FROM ${this.tableName} WHERE id = $1`;
-        const result = await this.client.query(query, [id]);
-        return result.rows[0] || null;
-    }
-    async create(data) {
-        const keys = Object.keys(data);
-        const values = Object.values(data);
-        const placeholders = keys.map((_, i) => `$${i + 1}`).join(', ');
-        const query = `INSERT INTO ${this.tableName} (${keys.join(', ')}) VALUES (${placeholders}) RETURNING *`;
-        const result = await this.client.query(query, values);
-        return result.rows[0];
-    }
-    async update(id, data) {
-        const keys = Object.keys(data);
-        const values = Object.values(data);
-        const setClauses = keys.map((key, i) => `${key} = $${i + 1}`).join(', ');
-        const query = `UPDATE ${this.tableName} SET ${setClauses} WHERE id = $${keys.length + 1} RETURNING *`;
-        const result = await this.client.query(query, [...values, id]);
-        return result.rows[0] || null;
-    }
-    async delete(id) {
-        const query = `DELETE FROM ${this.tableName} WHERE id = $1`;
-        const result = await this.client.query(query, [id]);
-        return result.rowCount > 0;
-    }
-}
-exports.SqlAdapter = SqlAdapter;

package/dist/models/modelManager.d.ts

@@ -1,2 +0,0 @@
-export { registerModel } from './registerModel';
-export { getModel } from './modelRegistry';

package/dist/models/modelManager.js

@@ -1,7 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getModel = exports.registerModel = void 0;
-var registerModel_1 = require("./registerModel");
-Object.defineProperty(exports, "registerModel", { enumerable: true, get: function () { return registerModel_1.registerModel; } });
-var modelRegistry_1 = require("./modelRegistry");
-Object.defineProperty(exports, "getModel", { enumerable: true, get: function () { return modelRegistry_1.getModel; } });

package/dist/models/modelRegistry.d.ts

@@ -1,3 +0,0 @@
-import { Model } from './Model';
-export declare const defineModel: (name: string, connectionId: string, tableName: string) => void;
-export declare const getModel: (name: string) => Model<any>;

package/dist/models/modelRegistry.js

@@ -1,17 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getModel = exports.defineModel = void 0;
-const Model_1 = require("./Model");
-const models = {};
-const defineModel = (name, connectionId, tableName) => {
-    models[name] = new Model_1.Model(connectionId, tableName);
-};
-exports.defineModel = defineModel;
-const getModel = (name) => {
-    const model = models[name];
-    if (!model) {
-        throw new Error(`Model ${name} not defined.`);
-    }
-    return model;
-};
-exports.getModel = getModel;

package/dist/models/registerModel.d.ts

@@ -1 +0,0 @@
-export declare const registerModel: (name: string, connectionId: string, tableName: string) => void;

package/dist/models/registerModel.js

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.registerModel = void 0;
-const modelRegistry_1 = require("./modelRegistry");
-const registerModel = (name, connectionId, tableName) => {
-    (0, modelRegistry_1.defineModel)(name, connectionId, tableName);
-};
-exports.registerModel = registerModel;

package/dist/providers/createStorageProvider.d.ts

@@ -1,2 +0,0 @@
-import { StorageAdapter, StorageProvider } from '../types';
-export declare const createStorageProvider: (providers: StorageProvider[]) => StorageAdapter;

package/dist/providers/createStorageProvider.js

@@ -1,12 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createStorageProvider = void 0;
-const s3_1 = require("../adapters/storage/s3");
-const createStorageProvider = (providers) => {
-    const s3Provider = providers.find(p => p.type === 's3');
-    if (s3Provider) {
-        return new s3_1.S3Adapter(s3Provider.config);
-    }
-    throw new Error('No storage provider configured.');
-};
-exports.createStorageProvider = createStorageProvider;