@medyll/idae-api 0.1.0 → 0.3.0

package/dist/server/IdaeApi.js

@@ -0,0 +1,213 @@
+// packages\idae-api\src\lib\IdaeApi.ts
+// version feat
+import express, {} from 'express';
+import { databaseMiddleware } from './middleware/databaseMiddleware';
+import { DBaseService } from './services/DBaseService';
+import { routes as defaultRoutes } from '../config/routeDefinitions';
+import { AuthMiddleWare } from './middleware/authMiddleware';
+import { RouteManager } from './engine/routeManager';
+class IdaeApi {
+    constructor() {
+        this._state = 'stopped';
+        this.authMiddleware = null;
+        this._app = express();
+        this.options = {};
+        this.routeManager = RouteManager.getInstance();
+        this.initializeAuth();
+        this.configureIdaeApi();
+    }
+    static getInstance() {
+        if (!IdaeApi.instance) {
+            IdaeApi.instance = new IdaeApi();
+        }
+        return IdaeApi.instance;
+    }
+    get state() {
+        return this._state;
+    }
+    get app() {
+        return this._app;
+    }
+    setOptions(options) {
+        this.options = { ...this.options, ...options };
+    }
+    initializeAuth() {
+        if (this.options.enableAuth && this.options.jwtSecret && this.options.tokenExpiration) {
+            this.authMiddleware = new AuthMiddleWare(this.options.jwtSecret, this.options.tokenExpiration);
+        }
+    }
+    configureIdaeApi() {
+        this.configureMiddleware();
+        this.configureRoutes();
+        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());
+        }
+    }
+    configureRoutes() {
+        this.routeManager.addRoutes(defaultRoutes);
+        if (this.options.routes) {
+            this.routeManager.addRoutes(this.options.routes);
+        }
+        this.routeManager.getRoutes().forEach(this.addRouteToExpress.bind(this));
+        if (this.authMiddleware) {
+            this.authMiddleware.configureAuthRoutes(this._app);
+        }
+    }
+    configureErrorHandling() {
+        this._app.use((err, req, res, next) => {
+            console.error(err.stack);
+            res.status(500).json({ error: err.message });
+        });
+    }
+    start() {
+        if (this._state === 'running') {
+            console.log('Server is already running.');
+            return;
+        }
+        const port = this.options.port || 3000;
+        this.serverInstance = this._app.listen(port, () => {
+            console.log(`Server is running on port: ${port}`);
+            this._state = 'running';
+        });
+        this.serverInstance.on('error', this.handleServerError.bind(this));
+    }
+    handleServerError(error) {
+        if (error.code === 'EADDRINUSE') {
+            console.error(`Port ${this.options.port} is already in use.`);
+            switch (this.options.onInUse) {
+                case 'reboot':
+                    console.log('Rebooting server...');
+                    setTimeout(() => {
+                        this.stop();
+                        this.start();
+                    }, 1000);
+                    break;
+                case 'replace':
+                    console.log('Replacing existing server...');
+                    this.stop();
+                    this.start();
+                    break;
+                default:
+                    console.log('Failed to start the server.');
+                    process.exit(1);
+            }
+        }
+        else {
+            throw error;
+        }
+    }
+    stop() {
+        if (this.serverInstance) {
+            this.serverInstance.close((err) => {
+                if (err) {
+                    console.error('Error while stopping the server:', err);
+                }
+                else {
+                    console.log('Server stopped successfully.');
+                    this._state = 'stopped';
+                }
+            });
+        }
+    }
+    // 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) {
+                    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);
+                res.json(result);
+            }
+            catch (error) {
+                next(error);
+            }
+        };
+    }
+    // Expose RouteManager methods
+    get router() {
+        return this.routeManager;
+    }
+}
+IdaeApi.instance = null;
+// Export a single instance of ApiServer
+const idaeApi = IdaeApi.getInstance();
+export { idaeApi };
+// Usage example:
+/*
+import apiServer from './ApiServer';
+import { RouteDefinition } from './config/routeDefinitions';
+
+// Configure the server
+apiServer.setOptions({
+    port: 3050,
+    enableAuth: true,
+    jwtSecret: 'your_jwt_secret',
+    tokenExpiration: '15m',
+    onInUse: 'reboot'
+});
+
+// Start the server
+apiServer.start();
+
+console.log(apiServer.state); // 'running'
+
+// Add a new route at runtime
+apiServer.router.addRoute({
+    method: 'post',
+    path: '/dynamic',
+    handler: async (service, params, body) => ({ message: 'Dynamic route', data: body })
+});
+
+// Disable a route
+apiServer.router.disableRoute('/custom', 'get');
+
+// Enable a route
+apiServer.router.enableRoute('/custom', 'get');
+
+// Add multiple routes
+apiServer.router.addRoutes([
+    {
+        method: 'get',
+        path: '/multiple1',
+        handler: async () => ({ message: 'Multiple 1' })
+    },
+    {
+        method: 'get',
+        path: '/multiple2',
+        handler: async () => ({ message: 'Multiple 2' })
+    }
+]);
+
+// Stop the server
+apiServer.stop();
+
+console.log(apiServer.state); // 'stopped'
+*/

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

@@ -0,0 +1,20 @@
+import type { ApiServerRequestParams } from '../engine/types';
+import type { Model, Document } from 'mongoose';
+import mongoose from 'mongoose';
+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

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

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

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

@@ -0,0 +1,12 @@
+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/engine/DatabaseManager.d.ts

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

@@ -0,0 +1,60 @@
+// packages\idae-api\src\lib\engine\DatabaseManager.ts
+import mongoose from 'mongoose';
+import dotenv from 'dotenv';
+import { mongooseConnectionManager } from './mongooseConnectionManager';
+// 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/engine/mongooseConnectionManager.d.ts

@@ -0,0 +1,11 @@
+import mongoose from 'mongoose';
+export declare class MongooseConnectionManager {
+    private static instance;
+    private constructor();
+    private _connections;
+    static getInstance(): MongooseConnectionManager;
+    createConnection(dbUri: string, dbName: string, options?: mongoose.ConnectOptions): Promise<mongoose.Connection>;
+    get connections(): Record<string, mongoose.Connection>;
+    getConnection(dbName: string): mongoose.Connection;
+}
+export declare const mongooseConnectionManager: MongooseConnectionManager;

package/dist/server/engine/mongooseConnectionManager.js

@@ -0,0 +1,25 @@
+// packages\idae-api\src\lib\engine\mongooseConnectionManager.ts
+import mongoose from 'mongoose';
+export class MongooseConnectionManager {
+    constructor() {
+        this._connections = {};
+    }
+    static getInstance() {
+        if (!MongooseConnectionManager.instance) {
+            MongooseConnectionManager.instance = new MongooseConnectionManager();
+        }
+        return MongooseConnectionManager.instance;
+    }
+    async createConnection(dbUri, dbName, options) {
+        const connection = await mongoose.createConnection(dbUri, options).asPromise();
+        this._connections[dbName] = connection;
+        return connection;
+    }
+    get connections() {
+        return this._connections;
+    }
+    getConnection(dbName) {
+        return this._connections?.[dbName];
+    }
+}
+export const mongooseConnectionManager = MongooseConnectionManager.getInstance();

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

@@ -0,0 +1,13 @@
+import type { RouteDefinition } from '../../config/routeDefinitions';
+export declare class RouteManager {
+    private static instance;
+    private routes;
+    private constructor();
+    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

@@ -0,0 +1,38 @@
+export class RouteManager {
+    constructor() {
+        this.routes = [];
+    }
+    static getInstance() {
+        if (!RouteManager.instance) {
+            RouteManager.instance = new RouteManager();
+        }
+        return RouteManager.instance;
+    }
+    addRoute(route) {
+        this.routes.push({ ...route, disabled: route.disabled || false });
+    }
+    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);
+    }
+    enableRoute(path, method) {
+        const route = this.routes.find((r) => r.path === path &&
+            (Array.isArray(r.method) ? r.method.includes(method) : r.method === method));
+        if (route) {
+            route.disabled = false;
+        }
+    }
+    disableRoute(path, method) {
+        const route = this.routes.find((r) => r.path === path &&
+            (Array.isArray(r.method) ? r.method.includes(method) : r.method === method));
+        if (route) {
+            route.disabled = true;
+        }
+    }
+}

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

@@ -0,0 +1,10 @@
+import type { FilterQuery } from 'mongoose';
+export interface ApiServerRequestParams<T extends object> {
+    id?: string;
+    query?: FilterQuery<T>;
+    sortBy?: string;
+    body?: any;
+}
+export interface SortOptions {
+    [key: string]: 1 | -1;
+}

package/dist/server/engine/types.js

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

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

@@ -0,0 +1,15 @@
+import type { Express, Request, Response, NextFunction } from 'express';
+declare class AuthMiddleWare {
+    private jwtSecret;
+    private tokenExpiration;
+    constructor(jwtSecret: string, tokenExpiration: string);
+    generateToken(payload: object): string;
+    verifyToken(token: string): any;
+    refreshToken(token: string): string;
+    createMiddleware(): (req: Request, res: Response, next: NextFunction) => Response<any, Record<string, any>> | undefined;
+    configureAuthRoutes(app: Express): void;
+    private handleLogin;
+    private handleLogout;
+    private handleRefreshToken;
+}
+export { AuthMiddleWare };