@medyll/idae-api 0.33.0 → 0.35.0

package/dist/@types/types.d.ts

@@ -1,3 +1,4 @@
+export { DbType } from "@medyll/idae-db";
 export interface ApiResponse<T extends object> {
     data?: T[];
     count?: number;

package/dist/@types/types.js

@@ -1 +1 @@
-export {};
+export { DbType } from "@medyll/idae-db";

package/dist/client/IdaeApiClientCollection.d.ts

@@ -1,10 +1,11 @@
 import { IdaeApiClient } from "./IdaeApiClient.js";
 import type { IdaeApiClientRequestParams } from "./IdaeApiClient.js";
 import type { IdaeApiClientConfigCoreOptions } from "./IdaeApiClientConfig.js";
-declare class IdaeApiClientCollection extends IdaeApiClient {
+import type { IdaeDbApiMethods } from "@medyll/idae-db";
+declare class IdaeApiClientCollection extends IdaeApiClient implements IdaeDbApiMethods<object> {
     private meta;
     constructor(clientConfig: IdaeApiClientConfigCoreOptions, dbName: string, collectionName: string);
-    findAll<T>(params?: IdaeApiClientRequestParams): Promise<Response>;
+    find<T extends object>(params?: IdaeApiClientRequestParams): Promise<T[]>;
     findById<T>(id: string): Promise<Response>;
     create<T>(body: T): Promise<Response>;
     update<T>(id: string, body: T): Promise<Response>;

package/dist/client/IdaeApiClientCollection.js

@@ -8,7 +8,7 @@ class IdaeApiClientCollection extends IdaeApiClient {
             collectionName,
         };
     }
-    async findAll(params) {
+    async find(params) {
         return this.request.doRequest({
             ...this.meta,
             params,

package/dist/client/IdaeApiClientRequest.js

@@ -1,5 +1,6 @@
 // packages\idae-api\src\lib\client\IdaeApiClientRequest.ts
 import { IdaeApiClientConfigCore } from "./IdaeApiClientConfig.js";
+import { encode } from "querystring";
 class IdaeApiClientRequest {
     constructor(clientConfig) {
         this.clientConfig = clientConfig;
@@ -40,7 +41,7 @@ class IdaeApiClientRequest {
         if (slug)
             urls.push(slug);
         if (params)
-            urls.push(`?${new URLSearchParams(params).toString()}`);
+            urls.push(`?params=${encodeURIComponent(JSON.stringify(params))}`);
         return urls.join("/").replace("//", "/");
     }
 }

package/dist/config/routeDefinitions.d.ts

@@ -1,10 +1,11 @@
-import { DBaseService } from "../server/services/DBaseService.js";
-type RouteHandler = (service: DBaseService<any>, params: any, body?: any) => Promise<any>;
+import type { IdaeDbAdapter } from "@medyll/idae-db";
+type RouteHandler = (service: IdaeDbAdapter<object>, params: any, body?: any, query?: any) => Promise<any>;
 export interface RouteDefinition {
     method: string | string[];
     path: string;
     handler: RouteHandler;
     disabled?: boolean;
+    requiresAuth?: boolean;
 }
 export declare const routes: RouteDefinition[];
 export {};

package/dist/config/routeDefinitions.js

@@ -1,10 +1,9 @@
 // packages\idae-api\src\lib\config\routeDefinitions.ts
-import { DBaseService } from "../server/services/DBaseService.js";
 export const routes = [
     {
         method: "get",
         path: "/:collectionName",
-        handler: async (service, params) => service.where(params),
+        handler: async (service, params, body, query) => service.find({ query }),
     },
     {
         method: "get",
@@ -29,15 +28,22 @@ export const routes = [
     {
         method: "delete",
         path: "/:collectionName",
-        handler: async (service, params) => service.deleteManyByQuery(params),
-    },
-    {
-        method: ["where", "create", "update", "deleteById", "deleteManyByQuery"], // default method is then GET or OPTIONS (set further)
+        handler: async (service, params) => service.deleteWhere(params),
+    },
+    {
+        method: [
+            "find",
+            "findById",
+            "findOne",
+            "create",
+            "update",
+            "updateWhere",
+            "deleteById",
+            "deleteWhere",
+            "transaction",
+        ], // default method is then GET or OPTIONS (set further)
         path: "/query/:collectionName/:command/:parameters?",
         handler: async (service, params, body) => {
-            const decodedParams = params.body
-                ? service.decodeUrlParams(params.body)
-                : {};
             console.log(params.command, "params --- ", { body });
             return service?.[params.command]?.({ query: body });
         },

package/dist/idae-api.d.ts

@@ -1,15 +1,18 @@
 // packages\idae-api\src\lib\idae-api.d.ts
 
-import mongoose from 'mongoose';
+import mongoose from "mongoose";
+import { IdaeDb, IdaeDbAdapter } from "@medyll/idae-db";
 
 declare global {
-	namespace Express {
-		interface Request {
-			dbConnection?: mongoose.Connection;
-			collectionName?: string;
-			dbName?: string;
-		}
-	}
+  namespace Express {
+    interface Request {
+      dbConnection?: mongoose.Connection;
+      collectionName?: string;
+      dbName?: string;
+      idaeDb?: IdaeDb;
+      connectedCollection: IdaeDbAdapter;
+    }
+  }
 }
 
 export {};

package/dist/index.d.ts

@@ -5,14 +5,10 @@ export * from './client/IdaeApiClientConfig.js';
 export * from './client/IdaeApiClientCollection.js';
 export * from './client/IdaeApiClient.js';
 export * from './@types/types.js';
-export * from './server/services/DBaseService.js';
 export * from './server/services/AuthService.js';
 export * from './server/middleware/databaseMiddleware.js';
 export * from './server/middleware/authMiddleware.js';
 export * from './server/engine/types.js';
 export * from './server/engine/routeManager.js';
+export * from './server/engine/requestDatabaseManager.js';
 export * from './server/engine/mongooseConnectionManager.js';
-export * from './server/engine/DatabaseManager.js';
-export * from './server/adapters/types.js';
-export * from './server/adapters/MySQLAdapter.js';
-export * from './server/adapters/MongoDBAdapter.js';

package/dist/index.js

@@ -6,14 +6,10 @@ export * from './client/IdaeApiClientConfig.js';
 export * from './client/IdaeApiClientCollection.js';
 export * from './client/IdaeApiClient.js';
 export * from './@types/types.js';
-export * from './server/services/DBaseService.js';
 export * from './server/services/AuthService.js';
 export * from './server/middleware/databaseMiddleware.js';
 export * from './server/middleware/authMiddleware.js';
 export * from './server/engine/types.js';
 export * from './server/engine/routeManager.js';
+export * from './server/engine/requestDatabaseManager.js';
 export * from './server/engine/mongooseConnectionManager.js';
-export * from './server/engine/DatabaseManager.js';
-export * from './server/adapters/types.js';
-export * from './server/adapters/MySQLAdapter.js';
-export * from './server/adapters/MongoDBAdapter.js';

package/dist/server/IdaeApi.d.ts

@@ -1,3 +1,4 @@
+import { type IdaeDbOptions } from "@medyll/idae-db";
 import express from "express";
 import { type RouteDefinition } from "../config/routeDefinitions.js";
 import { RouteManager } from "./engine/routeManager.js";
@@ -8,15 +9,10 @@ interface IdaeApiOptions {
     enableAuth?: boolean;
     jwtSecret?: string;
     tokenExpiration?: string;
+    idaeDbOptions?: IdaeDbOptions;
 }
 declare class IdaeApi {
-    private static instance;
-    private _app;
-    private options;
-    private routeManager;
-    private serverInstance;
-    private _state;
-    private authMiddleware;
+    #private;
     private constructor();
     static getInstance(): IdaeApi;
     get state(): "stopped" | "running";
@@ -26,11 +22,12 @@ declare class IdaeApi {
     configureIdaeApi(): void;
     private configureMiddleware;
     private configureRoutes;
+    private addRouteToExpress;
     private configureErrorHandling;
     start(): void;
+    get idaeApiOptions(): IdaeApiOptions;
     private handleServerError;
     stop(): void;
-    private addRouteToExpress;
     private handleRequest;
     get router(): RouteManager;
 }

package/dist/server/IdaeApi.js

@@ -1,41 +1,65 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _a, _IdaeApi_instance, _IdaeApi_app, _IdaeApi_idaeApiOptions, _IdaeApi_routeManager, _IdaeApi_serverInstance, _IdaeApi_state, _IdaeApi_authMiddleware;
 // packages\idae-api\src\lib\IdaeApi.ts
-// version feat
+import {} from "@medyll/idae-db";
 import express, {} from "express";
-import { databaseMiddleware } from "./middleware/databaseMiddleware.js";
-import { DBaseService } from "./services/DBaseService.js";
+import { idaeDbMiddleware } from "./middleware/databaseMiddleware.js";
 import { routes as defaultRoutes, } from "../config/routeDefinitions.js";
 import { AuthMiddleWare } from "./middleware/authMiddleware.js";
 import { RouteManager } from "./engine/routeManager.js";
+import qs from "qs";
 class IdaeApi {
     constructor() {
-        this._state = "stopped";
-        this.authMiddleware = null;
-        this._app = express();
-        this.options = {};
-        this.routeManager = RouteManager.getInstance();
+        _IdaeApi_app.set(this, void 0);
+        _IdaeApi_idaeApiOptions.set(this, void 0);
+        _IdaeApi_routeManager.set(this, void 0);
+        _IdaeApi_serverInstance.set(this, void 0);
+        _IdaeApi_state.set(this, "stopped");
+        _IdaeApi_authMiddleware.set(this, null);
+        __classPrivateFieldSet(this, _IdaeApi_app, express(), "f");
+        __classPrivateFieldSet(this, _IdaeApi_idaeApiOptions, {}, "f");
+        __classPrivateFieldSet(this, _IdaeApi_routeManager, RouteManager.getInstance(), "f");
+        __classPrivateFieldGet(this, _IdaeApi_app, "f").set("query parser", function (str) {
+            return qs.parse(str, {
+                parseArrays: true,
+                arrayLimit: Infinity,
+                depth: 10,
+                parameterLimit: 1000,
+            });
+        });
         this.initializeAuth();
         this.configureIdaeApi();
     }
     static getInstance() {
-        if (!IdaeApi.instance) {
-            IdaeApi.instance = new IdaeApi();
+        if (!__classPrivateFieldGet(_a, _a, "f", _IdaeApi_instance)) {
+            __classPrivateFieldSet(_a, _a, new _a(), "f", _IdaeApi_instance);
         }
-        return IdaeApi.instance;
+        return __classPrivateFieldGet(_a, _a, "f", _IdaeApi_instance);
     }
     get state() {
-        return this._state;
+        return __classPrivateFieldGet(this, _IdaeApi_state, "f");
     }
     get app() {
-        return this._app;
+        return __classPrivateFieldGet(this, _IdaeApi_app, "f");
     }
     setOptions(options) {
-        this.options = { ...this.options, ...options };
+        __classPrivateFieldSet(this, _IdaeApi_idaeApiOptions, { ...__classPrivateFieldGet(this, _IdaeApi_idaeApiOptions, "f"), ...options }, "f");
     }
     initializeAuth() {
-        if (this.options.enableAuth &&
-            this.options.jwtSecret &&
-            this.options.tokenExpiration) {
-            this.authMiddleware = new AuthMiddleWare(this.options.jwtSecret, this.options.tokenExpiration);
+        if (__classPrivateFieldGet(this, _IdaeApi_idaeApiOptions, "f").enableAuth &&
+            __classPrivateFieldGet(this, _IdaeApi_idaeApiOptions, "f").jwtSecret &&
+            __classPrivateFieldGet(this, _IdaeApi_idaeApiOptions, "f").tokenExpiration) {
+            __classPrivateFieldSet(this, _IdaeApi_authMiddleware, new AuthMiddleWare(__classPrivateFieldGet(this, _IdaeApi_idaeApiOptions, "f").jwtSecret, __classPrivateFieldGet(this, _IdaeApi_idaeApiOptions, "f").tokenExpiration), "f");
         }
     }
     configureIdaeApi() {
@@ -44,45 +68,62 @@ class IdaeApi {
         this.configureErrorHandling();
     }
     configureMiddleware() {
-        this._app.use("/:collectionName", databaseMiddleware);
-        this._app.use(express.json());
-        this._app.use(express.urlencoded({ extended: true }));
-        if (this.authMiddleware) {
-            this._app.use(this.authMiddleware.createMiddleware());
+        __classPrivateFieldGet(this, _IdaeApi_app, "f").use("/:collectionName", idaeDbMiddleware);
+        __classPrivateFieldGet(this, _IdaeApi_app, "f").use(express.json());
+        __classPrivateFieldGet(this, _IdaeApi_app, "f").use(express.urlencoded({ extended: true }));
+        if (__classPrivateFieldGet(this, _IdaeApi_authMiddleware, "f")) {
+            __classPrivateFieldGet(this, _IdaeApi_app, "f").use(__classPrivateFieldGet(this, _IdaeApi_authMiddleware, "f").createMiddleware());
         }
     }
     configureRoutes() {
-        this.routeManager.addRoutes(defaultRoutes);
-        if (this.options.routes) {
-            this.routeManager.addRoutes(this.options.routes);
+        __classPrivateFieldGet(this, _IdaeApi_routeManager, "f").addRoutes(defaultRoutes);
+        if (__classPrivateFieldGet(this, _IdaeApi_idaeApiOptions, "f").routes) {
+            __classPrivateFieldGet(this, _IdaeApi_routeManager, "f").addRoutes(__classPrivateFieldGet(this, _IdaeApi_idaeApiOptions, "f").routes);
+        }
+        __classPrivateFieldGet(this, _IdaeApi_routeManager, "f").getRoutes().forEach(this.addRouteToExpress.bind(this));
+        if (__classPrivateFieldGet(this, _IdaeApi_authMiddleware, "f")) {
+            __classPrivateFieldGet(this, _IdaeApi_authMiddleware, "f").configureAuthRoutes(__classPrivateFieldGet(this, _IdaeApi_app, "f"));
+        }
+    }
+    // Add a route to Express
+    addRouteToExpress(route) {
+        const handlers = [];
+        if (route.requiresAuth && __classPrivateFieldGet(this, _IdaeApi_authMiddleware, "f")) {
+            handlers.push(__classPrivateFieldGet(this, _IdaeApi_authMiddleware, "f").createMiddleware());
+        }
+        handlers.push(this.handleRequest(route.handler));
+        if (Array.isArray(route.method)) {
+            __classPrivateFieldGet(this, _IdaeApi_app, "f").post(route.path, ...handlers);
         }
-        this.routeManager.getRoutes().forEach(this.addRouteToExpress.bind(this));
-        if (this.authMiddleware) {
-            this.authMiddleware.configureAuthRoutes(this._app);
+        else {
+            __classPrivateFieldGet(this, _IdaeApi_app, "f")[route.method](route.path, ...handlers);
         }
     }
     configureErrorHandling() {
-        this._app.use((err, req, res, next) => {
+        __classPrivateFieldGet(this, _IdaeApi_app, "f").use((err, req, res, next) => {
             console.error(err.stack);
             res.status(500).json({ error: err.message });
         });
     }
     start() {
-        if (this._state === "running") {
+        if (__classPrivateFieldGet(this, _IdaeApi_state, "f") === "running") {
             console.log("Server is already running.");
             return;
         }
-        const port = this.options.port || 3000;
-        this.serverInstance = this._app.listen(port, () => {
+        const port = __classPrivateFieldGet(this, _IdaeApi_idaeApiOptions, "f").port || 3000;
+        __classPrivateFieldSet(this, _IdaeApi_serverInstance, __classPrivateFieldGet(this, _IdaeApi_app, "f").listen(port, () => {
             console.log(`Server is running on port: ${port}`);
-            this._state = "running";
-        });
-        this.serverInstance.on("error", this.handleServerError.bind(this));
+            __classPrivateFieldSet(this, _IdaeApi_state, "running", "f");
+        }), "f");
+        __classPrivateFieldGet(this, _IdaeApi_serverInstance, "f").on("error", this.handleServerError.bind(this));
+    }
+    get idaeApiOptions() {
+        return __classPrivateFieldGet(this, _IdaeApi_idaeApiOptions, "f");
     }
     handleServerError(error) {
         if (error.code === "EADDRINUSE") {
-            console.error(`Port ${this.options.port} is already in use.`);
-            switch (this.options.onInUse) {
+            console.error(`Port ${__classPrivateFieldGet(this, _IdaeApi_idaeApiOptions, "f").port} is already in use.`);
+            switch (__classPrivateFieldGet(this, _IdaeApi_idaeApiOptions, "f").onInUse) {
                 case "reboot":
                     console.log("Rebooting server...");
                     setTimeout(() => {
@@ -105,47 +146,33 @@ class IdaeApi {
         }
     }
     stop() {
-        if (this.serverInstance) {
-            this.serverInstance.close((err) => {
+        if (__classPrivateFieldGet(this, _IdaeApi_serverInstance, "f")) {
+            __classPrivateFieldGet(this, _IdaeApi_serverInstance, "f").close((err) => {
                 if (err) {
                     console.error("Error while stopping the server:", err);
                 }
                 else {
                     console.log("Server stopped successfully.");
-                    this._state = "stopped";
+                    __classPrivateFieldSet(this, _IdaeApi_state, "stopped", "f");
                 }
             });
         }
     }
-    // Add a route to Express
-    addRouteToExpress(route) {
-        const handlers = [];
-        if (route.requiresAuth && this.authMiddleware) {
-            handlers.push(this.authMiddleware.createMiddleware());
-        }
-        handlers.push(this.handleRequest(route.handler));
-        if (Array.isArray(route.method)) {
-            console.log({ handlers });
-            this._app.post(route.path, ...handlers);
-        }
-        else {
-            this._app[route.method](route.path, ...handlers);
-        }
-    }
     // Handle request
     handleRequest(action) {
         return async (req, res, next) => {
             try {
-                const { collectionName } = req.params;
-                const connection = req.dbConnection;
-                if (!connection) {
+                const connectedCollection = req.connectedCollection;
+                if (!connectedCollection) {
                     throw new Error("Database connection not established");
                 }
                 console.log("----------------------------------------------");
-                console.log(req.body);
-                console.log(req.params);
-                const databaseService = new DBaseService(collectionName, connection, "mongodb");
-                const result = await action(databaseService, req.params, req.body);
+                console.log("body", req.body);
+                console.log("params", req.params);
+                console.log("query", req.query);
+                console.log("dbName", req.dbName);
+                // const result = await action(databaseService, req.params, req.body);
+                const result = await action(connectedCollection, req.params, req.body, req.query.params ?? req.query);
                 res.json(result);
             }
             catch (error) {
@@ -155,10 +182,11 @@ class IdaeApi {
     }
     // Expose RouteManager methods
     get router() {
-        return this.routeManager;
+        return __classPrivateFieldGet(this, _IdaeApi_routeManager, "f");
     }
 }
-IdaeApi.instance = null;
+_a = IdaeApi, _IdaeApi_app = new WeakMap(), _IdaeApi_idaeApiOptions = new WeakMap(), _IdaeApi_routeManager = new WeakMap(), _IdaeApi_serverInstance = new WeakMap(), _IdaeApi_state = new WeakMap(), _IdaeApi_authMiddleware = new WeakMap();
+_IdaeApi_instance = { value: null };
 // Export a single instance of ApiServer
 const idaeApi = IdaeApi.getInstance();
 export { idaeApi };

package/dist/server/engine/requestDatabaseManager.d.ts

@@ -0,0 +1,22 @@
+import type { Request } from "express";
+export interface DatabaseConfigOptions {
+    port: number;
+    host: string;
+    defaultDbName: string;
+    connectionPrefix: string;
+}
+declare class RequestDatabaseManager {
+    private static instance;
+    config: DatabaseConfigOptions;
+    private constructor();
+    static getInstance(): RequestDatabaseManager;
+    fromReq(req: Request): {
+        dbName: string;
+        collectionName: string;
+        dbUri: string;
+    };
+    closeAllConnections(): Promise<void>;
+}
+declare const requestDatabaseManager: RequestDatabaseManager;
+export default requestDatabaseManager;
+export { RequestDatabaseManager as DatabaseManager, requestDatabaseManager };

package/dist/server/engine/requestDatabaseManager.js

@@ -0,0 +1,40 @@
+import dotenv from "dotenv";
+// Load environment variables
+dotenv.config();
+class RequestDatabaseManager {
+    constructor(config) {
+        this.config = {
+            port: Number(process.env.MONGODB_DEFAULT_PORT) || 27017,
+            host: process.env.MONGODB_DEFAULT_HOST || "localhost",
+            defaultDbName: process.env.MONGODB_DEFAULT_DB || "idaenext_sitebase_app",
+            connectionPrefix: process.env.MONGODB_DEFAULT_CONNECTION_PREFIX || "mongodb://",
+            ...config,
+        };
+    }
+    static getInstance() {
+        if (!RequestDatabaseManager.instance) {
+            RequestDatabaseManager.instance = new RequestDatabaseManager();
+        }
+        return RequestDatabaseManager.instance;
+    }
+    fromReq(req) {
+        const collectionName = req.params.collectionName || "default";
+        const dbName = getDbNameFromCollectionName(collectionName, this.config.defaultDbName);
+        const collectionNames = collectionName.split(".")?.[1] ?? collectionName.split(".")?.[0];
+        const dbUri = `${this.config.connectionPrefix}${this.config.host}:${this.config.port}/${dbName}`;
+        return {
+            dbName,
+            collectionName: collectionNames,
+            dbUri,
+        };
+        function getDbNameFromCollectionName(collectionName, defaultDbName) {
+            return collectionName.includes(".")
+                ? collectionName.split(".")[0]
+                : defaultDbName;
+        }
+    }
+    async closeAllConnections() { }
+}
+const requestDatabaseManager = RequestDatabaseManager.getInstance();
+export default requestDatabaseManager;
+export { RequestDatabaseManager as DatabaseManager, requestDatabaseManager };

package/dist/server/engine/routeManager.d.ts

@@ -6,7 +6,6 @@ export declare class RouteManager {
     static getInstance(): RouteManager;
     addRoute(route: RouteDefinition): void;
     addRoutes(routes: RouteDefinition[]): void;
-    removeRoute(path: string, method: string | string[]): void;
     getRoutes(): RouteDefinition[];
     enableRoute(path: string, method: string | string[]): void;
     disableRoute(path: string, method: string | string[]): void;

package/dist/server/engine/routeManager.js

@@ -14,12 +14,6 @@ export class RouteManager {
     addRoutes(routes) {
         routes.forEach((route) => this.addRoute(route));
     }
-    removeRoute(path, method) {
-        this.routes = this.routes.filter((r) => !(r.path === path &&
-            (Array.isArray(r.method)
-                ? r.method.includes(method)
-                : r.method === method)));
-    }
     getRoutes() {
         return this.routes.filter((route) => !route.disabled);
     }

package/dist/server/middleware/databaseMiddleware.d.ts

@@ -1,2 +1,2 @@
 import type { Request, Response, NextFunction } from "express";
-export declare const databaseMiddleware: (req: Request, res: Response, next: NextFunction) => Promise<void>;
+export declare const idaeDbMiddleware: (req: Request, res: Response, next: NextFunction) => Promise<void>;

package/dist/server/middleware/databaseMiddleware.js

@@ -1,11 +1,25 @@
 // packages\idae-api\src\lib\middleware\databaseMiddleware.ts
-import databaseManager from "../engine/DatabaseManager.js";
-export const databaseMiddleware = async (req, res, next) => {
+import { requestDatabaseManager } from "../engine/requestDatabaseManager.js";
+import { IdaeDb } from "@medyll/idae-db";
+import { idaeApi } from "../IdaeApi.js";
+export const idaeDbMiddleware = async (req, res, next) => {
     try {
-        const { collectionName, dbName, connection } = await databaseManager.connectToDatabase(req);
+        const { dbName, collectionName, dbUri } = requestDatabaseManager.fromReq(req);
         req.collectionName = collectionName;
-        req.dbConnection = connection;
         req.dbName = dbName;
+        req.idaeDb = IdaeDb.init(dbUri, idaeApi.idaeApiOptions.idaeDbOptions);
+        // create connection to db
+        await req.idaeDb.db("app");
+        req.connectedCollection = req.idaeDb.collection(collectionName);
+        console.log("Connected to collection", collectionName);
+        if (req.query.params) {
+            try {
+                req.query.params = JSON.parse(decodeURIComponent(req.query.params));
+            }
+            catch (error) {
+                console.error(error);
+            }
+        }
         next();
     }
     catch (error) {

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@medyll/idae-api",
 	"scope": "@medyll",
-	"version": "0.33.0",
+	"version": "0.35.0",
 	"main": "./dist/index.js",
 	"module": "./dist/index.js",
 	"scripts": {
@@ -41,6 +41,7 @@
 		"jsonwebtoken": "^9.0.2",
 		"mongoose": "^8.5.2",
 		"mongoose-sequence": "^6.0.1",
+		"qs": "^6.13.0",
 		"sequelize": "^6.37.3"
 	},
 	"devDependencies": {
@@ -78,4 +79,4 @@
 	"svelte": "./dist/index.js",
 	"types": "./dist/index.d.ts",
 	"type": "module"
-}
+}

package/dist/server/adapters/MongoDBAdapter.d.ts

@@ -1,21 +0,0 @@
-import type { ApiServerRequestParams } from "../engine/types.js";
-import type { Model, Document } from "mongoose";
-import mongoose from "mongoose";
-import type { DatabaseAdapter } from "./types.js";
-export declare class MongoDBAdapter<T extends Document> implements DatabaseAdapter<T> {
-    private model;
-    private connection;
-    constructor(collection: string, connection: mongoose.Connection);
-    create(document: Partial<T>): Promise<T>;
-    where(params: ApiServerRequestParams): Promise<T[]>;
-    findById(id: string): Promise<T | null>;
-    findOne(params: ApiServerRequestParams): Promise<T | null>;
-    update(id: string, updateData: Partial<T>): Promise<T | null>;
-    deleteById(id: string): Promise<T | null>;
-    deleteManyByQuery(params: ApiServerRequestParams): Promise<{
-        deletedCount?: number;
-    }>;
-    private parseSortOptions;
-    setModel(collection: string): Model<T, {}, {}, {}, mongoose.IfAny<T, any, Document<unknown, {}, T> & mongoose.Require_id<T>>, any>;
-    getModel: <T_1 extends Document>(collectionName: string) => Model<T_1>;
-}

package/dist/server/adapters/MongoDBAdapter.js

@@ -1,68 +0,0 @@
-// packages\idae-api\src\lib\adapters\MongoDBAdapter.ts
-import dotenv from "dotenv";
-import mongoose, { Schema } from "mongoose";
-// Load environment variables
-dotenv.config();
-// MongoDB Adapter
-export class MongoDBAdapter {
-    constructor(collection, connection) {
-        this.getModel = (collectionName) => {
-            if (this.connection.models[collectionName]) {
-                return this.connection.model(collectionName);
-            }
-            else {
-                return this.setModel(collectionName);
-            }
-        };
-        // just in case
-        collection = collection.split(".")[1] ?? collection.split(".")[0];
-        this.connection = connection;
-        this.model = this.getModel(collection);
-    }
-    async create(document) {
-        const newDocument = new this.model(document);
-        return newDocument.save();
-    }
-    async where(params) {
-        const { query = {}, sortBy, limit, skip } = params;
-        const sortOptions = this.parseSortOptions(sortBy);
-        return this.model
-            .find(query)
-            .sort(sortOptions)
-            .limit(Number(limit) || 0)
-            .skip(Number(skip) || 0);
-    }
-    async findById(id) {
-        return this.model.findById(id);
-    }
-    async findOne(params) {
-        return this.model.findOne(params.query);
-    }
-    async update(id, updateData) {
-        return this.model.findByIdAndUpdate(id, updateData, {
-            new: true,
-        });
-    }
-    async deleteById(id) {
-        return this.model.findByIdAndDelete(id);
-    }
-    async deleteManyByQuery(params) {
-        const result = await this.model.deleteMany(params.query);
-        return { deletedCount: result.deletedCount };
-    }
-    parseSortOptions(sortBy) {
-        const sortOptions = {};
-        if (sortBy) {
-            const sortFields = sortBy.split(",");
-            sortFields.forEach((field) => {
-                const [key, order] = field.split(":");
-                sortOptions[key] = order === "desc" ? -1 : 1;
-            });
-        }
-        return sortOptions;
-    }
-    setModel(collection) {
-        const schema = new Schema({}, { strict: false });
-        return this.connection.model(collection, schema, collection);
-    }
-}

package/dist/server/adapters/MySQLAdapter.d.ts

@@ -1,23 +0,0 @@
-import type { ApiServerRequestParams } from '../engine/types';
-import { Model } from 'sequelize';
-import type { DatabaseAdapter } from './types';
-interface MySQLDocument extends Model {
-    id: number;
-    [key: string]: any;
-}
-export declare class MySQLAdapter<T extends MySQLDocument> implements DatabaseAdapter<T> {
-    private sequelize;
-    private model;
-    constructor(tableName: string);
-    create(document: Partial<T>): Promise<T>;
-    where(params: ApiServerRequestParams): Promise<T[]>;
-    findById(id: string): Promise<T | null>;
-    findOne(params: ApiServerRequestParams): Promise<T | null>;
-    update(id: string, updateData: Partial<T>): Promise<T | null>;
-    deleteById(id: string): Promise<T | null>;
-    deleteManyByQuery(params: ApiServerRequestParams): Promise<{
-        deletedCount?: number;
-    }>;
-    private parseSortOptions;
-}
-export {};

package/dist/server/adapters/MySQLAdapter.js

@@ -1,78 +0,0 @@
-import { Sequelize, Model, DataTypes } from 'sequelize';
-import dotenv from 'dotenv';
-dotenv.config();
-export class MySQLAdapter {
-    constructor(tableName) {
-        this.sequelize = new Sequelize({
-            dialect: 'mysql',
-            host: process.env.MYSQL_HOST || 'localhost',
-            port: Number(process.env.MYSQL_PORT) || 3306,
-            database: process.env.MYSQL_DATABASE || 'database',
-            username: process.env.MYSQL_USER || 'root',
-            password: process.env.MYSQL_PASSWORD || 'password'
-        });
-        this.model = this.sequelize.define(tableName, {
-            id: {
-                type: DataTypes.INTEGER.UNSIGNED,
-                autoIncrement: true,
-                primaryKey: true
-            }
-            // Define other fields here as needed
-        }, {
-            timestamps: false,
-            tableName
-        });
-    }
-    async create(document) {
-        const newDocument = await this.model.create(document);
-        return newDocument;
-    }
-    async where(params) {
-        const { query = {}, sortBy, limit, skip } = params;
-        const options = {
-            where: query,
-            order: this.parseSortOptions(sortBy),
-            limit: limit ? Number(limit) : undefined,
-            offset: skip ? Number(skip) : undefined
-        };
-        const results = await this.model.findAll(options);
-        return results;
-    }
-    async findById(id) {
-        const result = await this.model.findByPk(id);
-        return result ? result : null;
-    }
-    async findOne(params) {
-        const { query = {} } = params;
-        const result = await this.model.findOne({ where: query });
-        return result ? result : null;
-    }
-    async update(id, updateData) {
-        const [affectedCount, affectedRows] = await this.model.update(updateData, {
-            where: { id },
-            returning: true
-        });
-        return affectedCount > 0 ? affectedRows[0] : null;
-    }
-    async deleteById(id) {
-        const result = await this.model.findByPk(id);
-        if (result) {
-            await result.destroy();
-            return result;
-        }
-        return null;
-    }
-    async deleteManyByQuery(params) {
-        const { query = {} } = params;
-        const deletedCount = await this.model.destroy({ where: query });
-        return { deletedCount };
-    }
-    parseSortOptions(sortBy) {
-        if (!sortBy)
-            return [];
-        return sortBy.split(',').map((field) => {
-            const [key, order] = field.split(':');
-            return [key, order === 'desc' ? 'DESC' : 'ASC'];
-        });
-    }
-}

package/dist/server/adapters/types.d.ts

@@ -1,12 +0,0 @@
-import type { ApiServerRequestParams } from '../engine/types';
-export interface DatabaseAdapter<T extends Document> {
-    create(document: Partial<T>): Promise<T>;
-    where(params: ApiServerRequestParams): Promise<T[]>;
-    findById(id: string): Promise<T | null>;
-    findOne(params: ApiServerRequestParams): Promise<T | null>;
-    update(id: string, updateData: Partial<T>): Promise<T | null>;
-    deleteById(id: string): Promise<T | null>;
-    deleteManyByQuery(params: ApiServerRequestParams): Promise<{
-        deletedCount?: number;
-    }>;
-}

package/dist/server/adapters/types.js

@@ -1 +0,0 @@
-export {};

package/dist/server/engine/DatabaseManager.d.ts

@@ -1,26 +0,0 @@
-import mongoose from "mongoose";
-import type { Request } from "express";
-export interface DatabaseConfig {
-    port: number;
-    host: string;
-    defaultDbName: string;
-    connectionPrefix: string;
-}
-declare class DatabaseManager {
-    private static instance;
-    private config;
-    private mongooseConnectionManager;
-    private constructor();
-    static getInstance(): DatabaseManager;
-    private getDbNameFromCollectionName;
-    private initConnection;
-    connectToDatabase(req: Request): Promise<{
-        connection?: mongoose.Connection;
-        dbName?: string;
-        collectionName?: string;
-    }>;
-    closeAllConnections(): Promise<void>;
-}
-declare const databaseManager: DatabaseManager;
-export default databaseManager;
-export { DatabaseManager, databaseManager };

package/dist/server/engine/DatabaseManager.js

@@ -1,62 +0,0 @@
-// packages\idae-api\src\lib\engine\DatabaseManager.ts
-import mongoose from "mongoose";
-import dotenv from "dotenv";
-import { mongooseConnectionManager, } from "./mongooseConnectionManager.js";
-// Load environment variables
-dotenv.config();
-class DatabaseManager {
-    constructor() {
-        this.mongooseConnectionManager = mongooseConnectionManager;
-        this.config = {
-            port: Number(process.env.MONGODB_DEFAULT_PORT) || 27017,
-            host: process.env.MONGODB_DEFAULT_HOST || "localhost",
-            defaultDbName: process.env.MONGODB_DEFAULT_DB || "idaenext_sitebase_app",
-            connectionPrefix: process.env.MONGODB_DEFAULT_CONNECTION_PREFIX || "mongodb://",
-        };
-    }
-    static getInstance() {
-        if (!DatabaseManager.instance) {
-            DatabaseManager.instance = new DatabaseManager();
-        }
-        return DatabaseManager.instance;
-    }
-    getDbNameFromCollectionName(collectionName) {
-        return collectionName.includes(".")
-            ? collectionName.split(".")[0]
-            : this.config.defaultDbName;
-    }
-    async initConnection(dbName) {
-        const dbUri = `${this.config.connectionPrefix}${this.config.host}:${this.config.port}/${dbName}`;
-        // use mongooseConnectionManager
-        const connection = await this.mongooseConnectionManager.createConnection(dbUri, dbName, {
-            dbName,
-            autoIndex: false,
-            bufferCommands: false,
-            serverSelectionTimeoutMS: 30000,
-            socketTimeoutMS: 45000,
-            maxPoolSize: 20,
-        });
-        return connection;
-    }
-    async connectToDatabase(req) {
-        const collectionName = req.params.collectionName || "default";
-        const dbName = this.getDbNameFromCollectionName(collectionName);
-        const collectionNames = collectionName.split(".")?.[1] ?? collectionName.split(".")?.[0];
-        try {
-            const connection = await this.initConnection(dbName);
-            return {
-                connection,
-                dbName,
-                collectionName: collectionNames,
-            };
-        }
-        catch (error) {
-            console.error(`Failed to connect to database ${dbName}:`, error);
-            throw new Error(`Failed to connect to database ${dbName}:`);
-        }
-    }
-    async closeAllConnections() { }
-}
-const databaseManager = DatabaseManager.getInstance();
-export default databaseManager;
-export { DatabaseManager, databaseManager };

package/dist/server/services/DBaseService.d.ts

@@ -1,17 +0,0 @@
-import mongoose, { type Document } from "mongoose";
-import { type ApiServerRequestParams } from "../engine/types.js";
-declare class DBaseService<T extends Document> {
-    private adapter;
-    constructor(collection: string, connection: mongoose.Connection, dbType?: "mongodb" | "mysql" | "mariadb" | "postgres");
-    create(document: Partial<T>): Promise<T>;
-    where(params: ApiServerRequestParams): Promise<T[]>;
-    findById(id: string): Promise<T | null>;
-    findOne(params: ApiServerRequestParams): Promise<T | null>;
-    update(id: string, updateData: Partial<T>): Promise<T | null>;
-    deleteById(id: string): Promise<T | null>;
-    deleteManyByQuery(params: ApiServerRequestParams): Promise<{
-        deletedCount?: number;
-    }>;
-    decodeUrlParams(urlParams: string): ApiServerRequestParams;
-}
-export { DBaseService };

package/dist/server/services/DBaseService.js

@@ -1,62 +0,0 @@
-// packages\idae-api\src\lib\engine\DBaseService.ts
-import mongoose, {} from "mongoose";
-import {} from "../engine/types.js";
-import { MongoDBAdapter } from "../adapters/MongoDBAdapter.js";
-class DBaseService {
-    constructor(collection, connection, dbType = "mongodb") {
-        switch (dbType) {
-            case "mongodb":
-                this.adapter = new MongoDBAdapter(collection, connection);
-                break;
-            case "mysql":
-            case "mariadb":
-                // TODO: Implement MySQL adapter
-                throw new Error("MySQL adapter not implemented yet");
-            case "postgres":
-                // TODO: Implement postgres adapter
-                throw new Error("Postgres adapter not implemented yet");
-            default:
-                console.log("dbType", dbType);
-                throw new Error(`Unsupported database type: ${dbType}`);
-        }
-    }
-    async create(document) {
-        return this.adapter.create(document);
-    }
-    async where(params) {
-        console.log("where", params);
-        return this.adapter.where(params);
-    }
-    async findById(id) {
-        return this.adapter.findById(id);
-    }
-    async findOne(params) {
-        return this.adapter.findOne(params);
-    }
-    async update(id, updateData) {
-        return this.adapter.update(id, updateData);
-    }
-    async deleteById(id) {
-        return this.adapter.deleteById(id);
-    }
-    async deleteManyByQuery(params) {
-        return this.adapter.deleteManyByQuery(params);
-    }
-    decodeUrlParams(urlParams) {
-        const params = {};
-        const urlParamsArray = urlParams.split("&");
-        urlParamsArray.forEach((param) => {
-            const [key, value] = param.split("=");
-            if (key && value) {
-                try {
-                    params[key] = JSON.parse(decodeURIComponent(value));
-                }
-                catch (error) {
-                    params[key] = decodeURIComponent(value);
-                }
-            }
-        });
-        return params;
-    }
-}
-export { DBaseService };