streamby-core 0.18.0 → 0.20.0

package/dist/middleware/createRouter.js

@@ -7,35 +7,25 @@ exports.createStreamByRouter = createStreamByRouter;
 const express_1 = __importDefault(require("express"));
 const file_1 = require("../services/file");
 const presign_1 = require("../services/presign");
-const createStorageProvider_1 = require("../providers/createStorageProvider");
-const createDatabaseProvider_1 = require("../providers/createDatabaseProvider");
+const manager_1 = require("../models/manager");
+const storage_1 = require("../providers/storage");
+const connectionManager_1 = require("../adapters/database/connectionManager");
 function isProjectMember(project, userId) {
     return project.members?.some((m) => m.userId?.toString() === userId?.toString());
 }
 function createStreamByRouter(config) {
     const router = express_1.default.Router();
-    const adapter = config.adapter || (0, createStorageProvider_1.createStorageProvider)(config.storageProviders);
-    const projectProviders = {};
-    let exportProvider;
-    let exportCollectionProvider;
+    const adapter = config.adapter || (0, storage_1.createStorageProvider)(config.storageProviders);
     if (config.databases) {
-        const db = (0, createDatabaseProvider_1.createDatabaseProvider)(config.databases, adapter);
-        projectProviders.nosql = db.projectProviders.nosql;
-        projectProviders.sql = db.projectProviders.sql;
-        exportProvider = db.exportProvider;
-        exportCollectionProvider = db.exportCollectionProvider;
-    }
-    else {
-        projectProviders.default = config.projectProvider;
-        exportProvider = config.exportProvider;
-        exportCollectionProvider = config.exportCollectionProvider;
-    }
-    if (!projectProviders.nosql && !projectProviders.sql) {
-        throw new Error('Project provider is not initialized. Please check your database configuration.');
-    }
-    if (!exportProvider) {
-        throw new Error('Export provider is not initialized. Please check your database configuration.');
+        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 Project = (0, manager_1.getModel)('Project');
+    const Export = (0, manager_1.getModel)('Export');
     router.get('/auth', async (req, res) => {
         try {
             const auth = await config.authProvider(req);
@@ -51,13 +41,10 @@ function createStreamByRouter(config) {
             if (!auth) {
                 return res.status(401).json({ error: 'Unauthorized' });
             }
-            const databases = [];
-            if (projectProviders.nosql) {
-                databases.push({ name: "NoSQL (Mongo)", value: "nosql" });
-            }
-            if (projectProviders.sql) {
-                databases.push({ name: "SQL (Prisma)", value: "sql" });
-            }
+            const connectedDbIds = (0, connectionManager_1.getConnectedIds)();
+            const databases = (config.databases || [])
+                .filter(db => connectedDbIds.includes(db.id))
+                .map(db => ({ name: db.id, value: db.type }));
             res.status(200).json({ databases });
         }
         catch (err) {
@@ -92,11 +79,7 @@ function createStreamByRouter(config) {
                 return res.status(400).json({ error: 'Missing projectId' });
             }
             await (0, file_1.deleteProjectImage)(adapter, projectId);
-            const provider = await getProjectProvider(projectId);
-            if (!provider) {
-                return res.status(404).json({ error: 'Project not found' });
-            }
-            const updated = await provider.update(projectId, { image: '' });
+            const updated = await Project.update({ _id: projectId }, { image: '' });
             res.status(201).json(updated);
         }
         catch (err) {
@@ -107,7 +90,7 @@ function createStreamByRouter(config) {
         try {
             const auth = await config.authProvider(req);
             const projectId = (req.query.projectId || req.headers['x-project-id']);
-            if (!projectId || !auth.projects.includes(projectId)) {
+            if (!projectId) {
                 return res.status(403).json({ error: 'Unauthorized or missing projectId' });
             }
             const files = await (0, file_1.listFilesService)(adapter, req, projectId);
@@ -117,52 +100,20 @@ function createStreamByRouter(config) {
             res.status(500).json({ error: 'Failed to list files', details: err });
         }
     });
-    async function getProjectProvider(projectId, dbType) {
-        if (dbType) {
-            const specificProvider = projectProviders[dbType];
-            if (specificProvider) {
-                try {
-                    const project = await specificProvider.getById(projectId, true);
-                    if (project)
-                        return specificProvider;
-                }
-                catch (error) { /* ignore */ }
-            }
-            return null; // If dbType was provided and no project found in that specific provider, return null.
-        }
-        // If dbType is not provided, search both nosql and sql
-        if (projectProviders.nosql) {
-            try {
-                const project = await projectProviders.nosql.getById(projectId, true);
-                if (project)
-                    return projectProviders.nosql;
-            }
-            catch (error) { /* ignore */ }
-        }
-        if (projectProviders.sql) {
-            try {
-                const project = await projectProviders.sql.getById(projectId, true);
-                if (project)
-                    return projectProviders.sql;
-            }
-            catch (error) { /* ignore */ }
-        }
-        return null; // If not found in either nosql or sql, return null.
-    }
     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 = [];
-            if (projectProviders.nosql) {
-                projects.push(...await projectProviders.nosql.list(auth.userId, archived));
-            }
-            if (projectProviders.sql) {
-                projects.push(...await projectProviders.sql.list(auth.userId, archived));
-            }
-            if (projectProviders.default) {
-                projects.push(...await projectProviders.default.list(auth.userId, archived));
-            }
+            const projects = (await Project.find({ members: { $elemMatch: { userId: auth.userId } }, archived })).map(project => {
+                const currentUserMember = project.members?.find((member) => member.userId === auth.userId);
+                return {
+                    id: project._id || project.id,
+                    dbType: project.dbType,
+                    name: project.name,
+                    image: project.image || '',
+                    archived: currentUserMember ? currentUserMember.archived || false : false,
+                };
+            });
             res.json({ projects });
         }
         catch (err) {
@@ -176,17 +127,13 @@ function createStreamByRouter(config) {
                 return res.status(403).json({ error: 'Permission denied' });
             }
             const { name, description, dbType } = req.body;
-            const provider = dbType ? projectProviders[dbType] : projectProviders.default || projectProviders.nosql || projectProviders.sql;
-            if (!provider) {
-                return res.status(400).json({ error: 'Invalid dbType' });
-            }
-            const newProject = await provider.create({
+            const newProject = await Project.create({
                 dbType: dbType || 'nosql',
                 name,
                 description: description || '',
-                members: [{ userId: auth.userId, role: "admin" }]
+                members: [{ userId: auth.userId, role: "admin", archived: false }]
             });
-            res.status(201).json({ project: newProject });
+            res.status(201).json({ project: { ...newProject, id: newProject._id || newProject.id, _id: undefined } });
         }
         catch (err) {
             res.status(500).json({ error: 'Failed to create project', details: err.message });
@@ -196,19 +143,14 @@ function createStreamByRouter(config) {
         try {
             const auth = await config.authProvider(req);
             const projectId = req.params.id;
-            const dbType = req.query.dbType;
-            const projectProvider = await getProjectProvider(projectId, dbType);
-            if (!projectProvider) {
-                return res.status(404).json({ error: 'Project not found' });
-            }
-            const project = await projectProvider.getById(projectId, true);
+            const project = await Project.findOne({ _id: projectId });
             if (!project) {
                 return res.status(404).json({ error: 'Project not found' });
             }
             if (!isProjectMember(project, auth.userId)) {
                 return res.status(403).json({ error: 'Unauthorized project access' });
             }
-            res.json({ project });
+            res.json({ project: { ...project, id: project._id || project.id, _id: undefined } });
         }
         catch (err) {
             res.status(500).json({ error: 'Failed to fetch project', details: err.message });
@@ -222,11 +164,7 @@ function createStreamByRouter(config) {
             }
             const projectId = req.params.id;
             const updates = req.body;
-            const projectProvider = await getProjectProvider(projectId);
-            if (!projectProvider) {
-                return res.status(404).json({ error: 'Project not found' });
-            }
-            const project = await projectProvider.getById(projectId, true);
+            const project = await Project.findOne({ _id: projectId });
             if (!project) {
                 return res.status(404).json({ error: 'Project not found' });
             }
@@ -236,8 +174,11 @@ function createStreamByRouter(config) {
             if (!isProjectMember(project, auth.userId)) {
                 return res.status(403).json({ error: 'Unauthorized project access' });
             }
-            const updated = await projectProvider.update(projectId, updates);
-            res.status(200).json({ success: true, project: updated });
+            const updated = await Project.update({ _id: projectId }, updates);
+            if (!updated) {
+                return res.status(404).json({ error: 'Project not found or not updated' });
+            }
+            res.status(200).json({ success: true, project: { ...updated, id: updated._id || updated.id, _id: undefined } });
         }
         catch (err) {
             res.status(500).json({ error: 'Failed to update project', details: err.message });
@@ -247,18 +188,14 @@ function createStreamByRouter(config) {
         try {
             const auth = await config.authProvider(req);
             const projectId = req.params.id;
-            const projectProvider = await getProjectProvider(projectId);
-            if (!projectProvider) {
-                return res.status(404).json({ error: 'Project not found' });
-            }
-            const project = await projectProvider.getById(projectId, true);
+            const project = await Project.findOne({ _id: projectId });
             if (!project) {
                 return res.status(404).json({ error: 'Project not found' });
             }
             if (!isProjectMember(project, auth.userId)) {
                 return res.status(403).json({ error: 'Unauthorized project access' });
             }
-            await projectProvider.delete(projectId);
+            await Project.delete({ _id: projectId });
             res.status(200).json({ success: true });
         }
         catch (err) {
@@ -269,26 +206,25 @@ function createStreamByRouter(config) {
         try {
             const auth = await config.authProvider(req);
             const projectId = req.params.id;
-            const projectProvider = await getProjectProvider(projectId);
-            if (!projectProvider) {
-                return res.status(404).json({ error: 'Project not found' });
-            }
-            const project = await projectProvider.getById(projectId, true);
+            const project = await Project.findOne({ _id: projectId });
             if (!project || !isProjectMember(project, auth.userId)) {
                 return res.status(403).json({ error: 'Unauthorized project access' });
             }
-            await projectProvider.archive(projectId, auth.userId);
-            const projects = [];
-            if (projectProviders.nosql) {
-                projects.push(...await projectProviders.nosql.list(auth.userId));
-            }
-            if (projectProviders.sql) {
-                projects.push(...await projectProviders.sql.list(auth.userId));
-            }
-            if (projectProviders.default) {
-                projects.push(...await projectProviders.default.list(auth.userId));
-            }
-            res.status(200).json({ success: true, projects });
+            await Project.update({ _id: projectId, "members.userId": auth.userId }, { "members.$.archived": true, "members.$.archivedBy": auth.userId, "members.$.archivedAt": new Date() });
+            const updatedProject = await Project.findOne({ _id: projectId }); // Fetch the updated project
+            const projects = (await Project.find({ members: { $elemMatch: { userId: auth.userId } } })).map(project => {
+                const currentUserMember = project.members?.find((member) => member.userId === auth.userId);
+                return {
+                    id: project._id || project.id,
+                    dbType: project.dbType,
+                    name: project.name,
+                    image: project.image || '',
+                    archived: currentUserMember ? currentUserMember.archived || false : false,
+                };
+            });
+            // Replace the old project with the updated one in the list
+            const finalProjects = projects.map(p => p.id === (updatedProject?._id || updatedProject?.id) ? ({ ...updatedProject, id: updatedProject._id || updatedProject.id, _id: undefined }) : p);
+            res.status(200).json({ success: true, projects: finalProjects });
         }
         catch (err) {
             res.status(500).json({ error: 'Failed to archive project', details: err.message });
@@ -298,26 +234,25 @@ function createStreamByRouter(config) {
         try {
             const auth = await config.authProvider(req);
             const projectId = req.params.id;
-            const projectProvider = await getProjectProvider(projectId);
-            if (!projectProvider) {
-                return res.status(404).json({ error: 'Project not found' });
-            }
-            const project = await projectProvider.getById(projectId, true);
+            const project = await Project.findOne({ _id: projectId });
             if (!project || !isProjectMember(project, auth.userId)) {
                 return res.status(403).json({ error: 'Unauthorized project access' });
             }
-            await projectProvider.unarchive(projectId, auth.userId);
-            const projects = [];
-            if (projectProviders.nosql) {
-                projects.push(...await projectProviders.nosql.list(auth.userId));
-            }
-            if (projectProviders.sql) {
-                projects.push(...await projectProviders.sql.list(auth.userId));
-            }
-            if (projectProviders.default) {
-                projects.push(...await projectProviders.default.list(auth.userId));
-            }
-            res.status(200).json({ success: true, projects });
+            await Project.update({ _id: projectId, "members.userId": auth.userId }, { "members.$.archived": false, "members.$.archivedBy": null, "members.$.archivedAt": null });
+            const updatedProject = await Project.findOne({ _id: projectId }); // Fetch the updated project
+            const projects = (await Project.find({ members: { $elemMatch: { userId: auth.userId } } })).map(project => {
+                const currentUserMember = project.members?.find((member) => member.userId === auth.userId);
+                return {
+                    id: project._id || project.id,
+                    dbType: project.dbType,
+                    name: project.name,
+                    image: project.image || '',
+                    archived: currentUserMember ? currentUserMember.archived || false : false,
+                };
+            });
+            // Replace the old project with the updated one in the list
+            const finalProjects = projects.map(p => p.id === (updatedProject?._id || updatedProject?.id) ? ({ ...updatedProject, id: updatedProject._id || updatedProject.id, _id: undefined }) : p);
+            res.status(200).json({ success: true, projects: finalProjects });
         }
         catch (err) {
             res.status(500).json({ error: 'Failed to unarchive project', details: err.message });
@@ -328,19 +263,15 @@ function createStreamByRouter(config) {
             const auth = await config.authProvider(req);
             const projectId = req.params.id;
             const exportId = req.params.export_id;
-            const projectProvider = await getProjectProvider(projectId);
-            if (!projectProvider) {
-                return res.status(404).json({ error: 'Project not found' });
-            }
-            const project = await projectProvider.getById(projectId, true);
+            const project = await Project.findOne({ _id: projectId });
             if (!project) {
                 return res.status(404).json({ error: 'Project not found' });
             }
             if (!isProjectMember(project, auth.userId)) {
                 return res.status(403).json({ error: 'Unauthorized access' });
             }
-            const data = await exportProvider.getById(exportId);
-            res.json({ data });
+            const data = await Export.findOne({ _id: exportId });
+            res.json({ data: { ...data, id: data._id || data.id, _id: undefined } });
         }
         catch (err) {
             res.status(500).json({ error: 'Failed to fetch export data', details: err.message });
@@ -354,22 +285,18 @@ function createStreamByRouter(config) {
             if (!name || !collectionName) {
                 return res.status(400).json({ error: 'Missing export name or collectionName' });
             }
-            const projectProvider = await getProjectProvider(projectId);
-            if (!projectProvider) {
-                return res.status(404).json({ error: 'Project not found' });
-            }
-            const project = await projectProvider.getById(projectId, true);
+            const project = await Project.findOne({ _id: projectId });
             if (!project || !isProjectMember(project, auth.userId)) {
                 return res.status(403).json({ error: 'Unauthorized project access' });
             }
-            const newExport = await exportProvider.create({
+            const newExport = await Export.create({
                 name,
                 description,
                 collectionName,
                 projectId
             });
-            await projectProvider.addExportToProject(projectId, newExport.id);
-            res.status(201).json({ data: newExport });
+            await Project.update({ _id: projectId }, { $push: { exports: newExport._id } });
+            res.status(201).json({ data: { ...newExport, id: newExport._id || newExport.id, _id: undefined } });
         }
         catch (err) {
             res.status(500).json({ error: 'Failed to create export', details: err.message });
@@ -379,11 +306,7 @@ function createStreamByRouter(config) {
         try {
             const auth = await config.authProvider(req);
             const projectId = req.params.id;
-            const projectProvider = await getProjectProvider(projectId);
-            if (!projectProvider) {
-                return res.status(404).json({ error: 'Project not found' });
-            }
-            const project = await projectProvider.getById(projectId, true);
+            const project = await Project.findOne({ _id: projectId });
             if (!project) {
                 return res.status(404).json({ error: 'Project not found' });
             }

package/dist/models/Model.d.ts

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

package/dist/models/Model.js

@@ -0,0 +1,146 @@
+"use strict";
+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");
+class Model {
+    constructor(connectionIds, tableName) {
+        this.connectionIds = connectionIds;
+        this.tableName = tableName;
+    }
+    async find(filter) {
+        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);
+                for (const item of sqlResults) {
+                    allResults.push(this.transformResult(item));
+                }
+            }
+            else if (connection instanceof mongodb_1.MongoClient) {
+                const nosqlResults = await nosql_1.nosqlAdapter.find(connection, this.tableName, filter);
+                for (const item of nosqlResults) {
+                    allResults.push(this.transformResult(item));
+                }
+            }
+        }
+        return allResults;
+    }
+    transformResult(item) {
+        const transformedItem = { ...item };
+        if (transformedItem._id && !transformedItem.id) {
+            transformedItem.id = transformedItem._id.toString();
+        }
+        return transformedItem;
+    }
+    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);
+            let processedFilter = { ...filter };
+            if (connection instanceof pg_1.Pool) {
+                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;
+            }
+            else if (connection instanceof mongodb_1.MongoClient) {
+                const result = await nosql_1.nosqlAdapter.findOne(connection, this.tableName, processedFilter);
+                if (result)
+                    return result;
+            }
+        }
+        return null;
+    }
+    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);
+            return created;
+        }
+        else if (connection instanceof mongodb_1.MongoClient) {
+            const created = await nosql_1.nosqlAdapter.create(connection, this.tableName, data);
+            return created;
+        }
+        return data;
+    }
+    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);
+            let processedFilter = { ...filter };
+            // Handle specific member archiving/unarchiving
+            if (data["members.$.archived"] !== undefined && processedFilter["_id"] && processedFilter["members.userId"]) {
+                const projectId = processedFilter["_id"];
+                const userIdToUpdate = processedFilter["members.userId"];
+                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 };
+                    }
+                    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 {
+                // General update logic
+                if (connection instanceof pg_1.Pool) {
+                    if (processedFilter._id) {
+                        processedFilter.id = processedFilter._id;
+                        delete processedFilter._id;
+                    }
+                    const result = await sql_1.sqlAdapter.update(connection, this.tableName, processedFilter, data);
+                    if (result)
+                        return result;
+                }
+                else if (connection instanceof mongodb_1.MongoClient) {
+                    const result = await nosql_1.nosqlAdapter.update(connection, this.tableName, processedFilter, data);
+                    if (result)
+                        return result;
+                }
+            }
+        }
+        return null;
+    }
+    async delete(filter) {
+        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);
+            let processedFilter = { ...filter };
+            if (connection instanceof pg_1.Pool) {
+                if (processedFilter._id) {
+                    processedFilter.id = processedFilter._id;
+                    delete processedFilter._id;
+                }
+                const count = await sql_1.sqlAdapter.delete(connection, this.tableName, processedFilter);
+                deletedCount += count;
+            }
+            else if (connection instanceof mongodb_1.MongoClient) {
+                const count = await nosql_1.nosqlAdapter.delete(connection, this.tableName, processedFilter);
+                deletedCount += count;
+            }
+        }
+        return deletedCount;
+    }
+}
+exports.Model = Model;

package/dist/models/manager.d.ts

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

package/dist/models/manager.js

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

package/dist/models/modelManager.d.ts

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

package/dist/models/modelManager.js

@@ -0,0 +1,7 @@
+"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

@@ -0,0 +1,3 @@
+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

@@ -0,0 +1,17 @@
+"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/register.d.ts

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

package/dist/models/register.js

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

package/dist/models/registerModel.d.ts

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

package/dist/models/registerModel.js

@@ -0,0 +1,8 @@
+"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/models/registry.d.ts

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

package/dist/models/registry.js

@@ -0,0 +1,17 @@
+"use strict";
+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);
+};
+exports.defineModel = defineModel;
+const getModel = (name) => {
+    const model = models[name];
+    if (!model) {
+        throw new Error(`Model ${name} not defined.`);
+    }
+    return model;
+};
+exports.getModel = getModel;