@medyll/idae-api 0.1.0 → 0.3.0

package/dist/server/middleware/authMiddleware.js

@@ -0,0 +1,83 @@
+// packages\idae-api\src\lib\authMiddleware.ts
+import jwt from 'jsonwebtoken';
+class AuthMiddleWare {
+    constructor(jwtSecret, tokenExpiration) {
+        this.jwtSecret = jwtSecret;
+        this.tokenExpiration = tokenExpiration;
+    }
+    // Generate a JWT token
+    generateToken(payload) {
+        return jwt.sign(payload, this.jwtSecret, { expiresIn: this.tokenExpiration });
+    }
+    // Verify a JWT token
+    verifyToken(token) {
+        try {
+            return jwt.verify(token, this.jwtSecret);
+        }
+        catch (error) {
+            throw new Error('Invalid token');
+        }
+    }
+    // Refresh a JWT token
+    refreshToken(token) {
+        const payload = this.verifyToken(token);
+        delete payload.iat;
+        delete payload.exp;
+        return this.generateToken(payload);
+    }
+    // Middleware to verify JWT token
+    createMiddleware() {
+        return (req, res, next) => {
+            const authHeader = req.headers.authorization;
+            if (!authHeader || !authHeader.startsWith('Bearer ')) {
+                return res.status(401).json({ error: 'Unauthorized' });
+            }
+            const token = authHeader.split(' ')[1];
+            try {
+                const user = this.verifyToken(token);
+                req.user = user; // Attach user info to the request object
+                next();
+            }
+            catch (error) {
+                return res.status(401).json({ error: 'Unauthorized' });
+            }
+        };
+    }
+    // Configure authentication routes
+    configureAuthRoutes(app) {
+        app.post('/login', this.handleLogin.bind(this));
+        app.post('/logout', this.handleLogout.bind(this));
+        app.post('/refresh-token', this.handleRefreshToken.bind(this));
+    }
+    // Handle login
+    handleLogin(req, res) {
+        const { username, password } = req.body;
+        // Validate user credentials (this is a placeholder, replace with actual validation logic)
+        if (username === 'admin' && password === 'password') {
+            const payload = { username };
+            const token = this.generateToken(payload);
+            res.json({ token });
+        }
+        else {
+            res.status(401).json({ error: 'Invalid credentials' });
+        }
+    }
+    // Handle logout
+    handleLogout(req, res) {
+        // Invalidate the token (this is a placeholder, implement actual token invalidation logic if needed)
+        res.json({ message: 'Logged out successfully' });
+    }
+    // Handle token refresh
+    handleRefreshToken(req, res) {
+        const { token } = req.body;
+        try {
+            const newToken = this.refreshToken(token);
+            res.json({ token: newToken });
+        }
+        catch (error) {
+            res.status(401).json({ error: 'Invalid token' });
+        }
+    }
+}
+// always use named exports !
+export { AuthMiddleWare };

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

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

package/dist/server/middleware/databaseMiddleware.js

@@ -0,0 +1,15 @@
+// packages\idae-api\src\lib\middleware\databaseMiddleware.ts
+import databaseManager from '../engine/DatabaseManager';
+export const databaseMiddleware = async (req, res, next) => {
+    try {
+        const { collectionName, dbName, connection } = await databaseManager.connectToDatabase(req);
+        req.collectionName = collectionName;
+        req.dbConnection = connection;
+        req.dbName = dbName;
+        next();
+    }
+    catch (error) {
+        console.error('Error in database connection middleware:', error);
+        next(error);
+    }
+};

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

@@ -0,0 +1,13 @@
+import type { Express } from 'express';
+export declare class AuthService {
+    private jwtSecret;
+    private tokenExpiration;
+    constructor(jwtSecret: string, tokenExpiration: string);
+    generateToken(payload: object): string;
+    verifyToken(token: string): any;
+    refreshToken(token: string): string;
+    configureAuthRoutes(app: Express): void;
+    private handleLogin;
+    private handleLogout;
+    private handleRefreshToken;
+}

package/dist/server/services/AuthService.js

@@ -0,0 +1,56 @@
+// packages\idae-api\src\lib\services\AuthService.ts
+import jwt from 'jsonwebtoken';
+export class AuthService {
+    constructor(jwtSecret, tokenExpiration) {
+        this.jwtSecret = jwtSecret;
+        this.tokenExpiration = tokenExpiration;
+    }
+    generateToken(payload) {
+        return jwt.sign(payload, this.jwtSecret, { expiresIn: this.tokenExpiration });
+    }
+    verifyToken(token) {
+        try {
+            return jwt.verify(token, this.jwtSecret);
+        }
+        catch (error) {
+            throw new Error('Invalid token');
+        }
+    }
+    refreshToken(token) {
+        const payload = this.verifyToken(token);
+        delete payload.iat;
+        delete payload.exp;
+        return this.generateToken(payload);
+    }
+    configureAuthRoutes(app) {
+        app.post('/login', this.handleLogin.bind(this));
+        app.post('/logout', this.handleLogout.bind(this));
+        app.post('/refresh-token', this.handleRefreshToken.bind(this));
+    }
+    handleLogin(req, res) {
+        const { username, password } = req.body;
+        // Validate user credentials (this is a placeholder, replace with actual validation logic)
+        if (username === 'admin' && password === 'password') {
+            const payload = { username };
+            const token = this.generateToken(payload);
+            res.json({ token });
+        }
+        else {
+            res.status(401).json({ error: 'Invalid credentials' });
+        }
+    }
+    handleLogout(req, res) {
+        // Invalidate the token (this is a placeholder, implement actual token invalidation logic if needed)
+        res.json({ message: 'Logged out successfully' });
+    }
+    handleRefreshToken(req, res) {
+        const { token } = req.body;
+        try {
+            const newToken = this.refreshToken(token);
+            res.json({ token: newToken });
+        }
+        catch (error) {
+            res.status(401).json({ error: 'Invalid token' });
+        }
+    }
+}

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

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

@@ -0,0 +1,62 @@
+// packages\idae-api\src\lib\engine\DBaseService.ts
+import mongoose, {} from 'mongoose';
+import {} from '../engine/types';
+import { MongoDBAdapter } from '../adapters/MongoDBAdapter';
+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 };

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@medyll/idae-api",
 	"scope": "@medyll",
-	"version": "0.1.0",
+	"version": "0.3.0",
 	"scripts": {
 		"dev": "vite dev",
 		"build": "vite build && npm run package",
@@ -27,36 +27,47 @@
 		"!dist/**/*.spec.*"
 	],
 	"dependencies": {
+		"@typegoose/auto-increment": "^4.5.0",
 		"express": "^4.19.2",
-		"mongoose-sequence": "^6.0.1"
+		"jsonwebtoken": "^9.0.2",
+		"mongoose": "^8.5.2",
+		"mongoose-sequence": "^6.0.1",
+		"sequelize": "^6.37.3"
 	},
 	"peerDependencies": {
 		"svelte": "^5.0.0-next.1"
 	},
 	"devDependencies": {
 		"@medyll/idae-prettier-config": "^1.0.0",
-		"@sveltejs/adapter-auto": "^3.0.0",
-		"@sveltejs/kit": "^2.0.0",
-		"@sveltejs/package": "^2.0.0",
-		"@sveltejs/vite-plugin-svelte": "^3.0.0",
-		"@types/eslint": "^8.56.7",
+		"@sveltejs/adapter-auto": "^3.2.2",
+		"@sveltejs/kit": "^2.5.20",
+		"@sveltejs/package": "^2.3.2",
+		"@sveltejs/vite-plugin-svelte": "^3.1.1",
+		"@types/eslint": "^9.6.0",
 		"@types/express": "^4.17.21",
+		"@types/jest": "^29.5.12",
+		"@types/jsonwebtoken": "^9.0.6",
 		"@types/mongoose": "^5.11.97",
-		"eslint": "^9.0.0",
+		"@types/mongoose-sequence": "^3.0.11",
+		"@types/supertest": "^6.0.2",
+		"eslint": "^9.8.0",
 		"eslint-config-prettier": "^9.1.0",
-		"eslint-plugin-svelte": "^2.36.0",
-		"globals": "^15.0.0",
-		"prettier": "^3.1.1",
-		"prettier-plugin-svelte": "^3.1.2",
-		"publint": "^0.1.9",
+		"eslint-plugin-svelte": "^2.43.0",
+		"globals": "^15.9.0",
+		"jest": "^29.7.0",
+		"mongodb-memory-server": "^10.0.0",
+		"mysql2": "^3.11.0",
+		"prettier": "^3.3.3",
+		"prettier-plugin-svelte": "^3.2.6",
+		"supertest": "^7.0.0",
 		"svelte": "^5.0.0-next.183",
-		"svelte-check": "^3.6.0",
-		"tslib": "^2.4.1",
-		"tsx": "^4.16.2",
-		"typescript": "^5.0.0",
-		"typescript-eslint": "^8.0.0-alpha.20",
-		"vite": "^5.0.11",
-		"vitest": "^1.2.0"
+		"svelte-check": "^3.8.5",
+		"tslib": "^2.6.3",
+		"tsx": "^4.16.5",
+		"typescript": "^5.5.4",
+		"typescript-eslint": "^8.0.0",
+		"vite": "^5.3.5",
+		"vitest": "^2.0.5"
 	},
 	"svelte": "./dist/index.js",
 	"types": "./dist/index.d.ts",

package/dist/ApiServe.d.ts

@@ -1,10 +0,0 @@
-export declare class ApiServe {
-    private app;
-    private port;
-    constructor(port?: number);
-    private configureMiddleware;
-    private getDynamicModel;
-    private getCollectionName;
-    private configureRoutes;
-    start(): void;
-}

package/dist/ApiServe.js

@@ -1,113 +0,0 @@
-// ServerConfig.ts
-import express, {} from 'express';
-import DBaseService from './engine/DBaseService.js';
-import DatabaseManager from './engine/DBaseManager.js';
-import mongoose, { Schema, Model, Document } from 'mongoose';
-export class ApiServe {
-    constructor(port = 3000) {
-        this.app = express();
-        this.port = port;
-        this.configureMiddleware();
-        this.configureRoutes();
-    }
-    configureMiddleware() {
-        this.app.use(express.json());
-    }
-    getDynamicModel(collectionName) {
-        if (mongoose.models[collectionName]) {
-            return mongoose.models[collectionName];
-        }
-        const schema = new Schema({}, { strict: false });
-        return mongoose.model(collectionName, schema, collectionName);
-    }
-    getCollectionName(collectionName) {
-        let dbName, collection;
-        if (collectionName.includes('.')) {
-            [dbName, collection] = collectionName.split('.');
-        }
-        else {
-            collection = collectionName;
-        }
-        return collection;
-    }
-    configureRoutes() {
-        this.app.use('/:collectionName', DatabaseManager.connectToDatabase);
-        this.app.get('/:collectionName', async (req, res) => {
-            try {
-                const { collectionName } = req.params;
-                const collection = this.getCollectionName(collectionName);
-                const databaseService = new DBaseService(collection);
-                const documents = await databaseService.findAll(req.query);
-                res.send(documents);
-            }
-            catch (error) {
-                res.status(500).send(error);
-            }
-        });
-        this.app.get('/:collectionName/:id', async (req, res) => {
-            try {
-                const { collectionName, id } = req.params;
-                const collection = this.getCollectionName(collectionName);
-                const databaseService = new DBaseService(collection);
-                const document = await databaseService.findById(id);
-                if (!document) {
-                    return res.status(404).send({ error: 'Document not found' });
-                }
-                res.send(document);
-            }
-            catch (error) {
-                res.status(500).send(error);
-            }
-        });
-        this.app.delete('/:collectionName/:id', async (req, res) => {
-            try {
-                const { collectionName, id } = req.params;
-                const collection = this.getCollectionName(collectionName);
-                const databaseService = new DBaseService(collection);
-                const result = await databaseService.deleteById(id);
-                res.send(result);
-            }
-            catch (error) {
-                res.status(500).send(error);
-            }
-        });
-        this.app.delete('/:collectionName/', async (req, res) => {
-            try {
-                const { collectionName } = req.params;
-                const collection = this.getCollectionName(collectionName);
-                const databaseService = new DBaseService(collection);
-                const result = await databaseService.deleteManyByQuery(req.query);
-                res.send(result);
-            }
-            catch (error) {
-                res.status(500).send(error);
-            }
-        });
-        const directCommands = ['findAll', 'create', 'update', 'deleteById', 'deleteManyByQuery'];
-        this.app.all('/:collectionName/:command/:params?', async (req, res) => {
-            try {
-                const { collectionName, command, params } = req.params;
-                const collection = this.getCollectionName(collectionName);
-                if (!directCommands.includes(command)) {
-                    return res.status(400).send({ error: 'Command not supported' });
-                }
-                const databaseService = new DBaseService(collection);
-                const decodedParams = params ? databaseService.decodeUrlParams(params) : {};
-                const result = await databaseService[command](decodedParams);
-                res.status(200).send(result);
-            }
-            catch (error) {
-                res.status(400).send({ error: error.message });
-            }
-        });
-    }
-    start() {
-        this.app.listen(this.port, () => {
-            console.log(`Server is running on port: ${this.port}`);
-        });
-    }
-}
-// Usage:
-// import { ServerConfig } from './ServerConfig.js';
-// const server = new ApiServer(3050);
-// server.start();

package/dist/engine/DBaseManager.d.ts

@@ -1,15 +0,0 @@
-import type { Request, Response, NextFunction } from 'express';
-declare const defaultDbName: string;
-declare class DBaseManager {
-    private static instance;
-    static port: number;
-    constructor();
-    static getInstance(): DBaseManager;
-    connectToDatabase(req: Request<{
-        dbName: string;
-        collectionName: string;
-    }>, res: Response, next: NextFunction): Promise<void>;
-}
-declare const _default: DBaseManager;
-export default _default;
-export { DBaseManager as DatabaseManager, defaultDbName };

package/dist/engine/DBaseManager.js

@@ -1,49 +0,0 @@
-import mongoose from 'mongoose';
-const defaultDbName = 'idae';
-// this is my middleware to connect to the appropriate database
-class DBaseManager {
-    constructor() { }
-    static getInstance() {
-        if (!DBaseManager.instance) {
-            DBaseManager.instance = new DBaseManager();
-        }
-        return DBaseManager.instance;
-    }
-    async connectToDatabase(req, res, next) {
-        const { collectionName } = req.params;
-        let dbName;
-        //
-        if (collectionName.includes('.')) {
-            dbName = collectionName.split('.')[0];
-        }
-        else {
-            dbName = defaultDbName;
-        }
-        const dbUri = `mongodb://localhost:${DBaseManager.port}/${dbName}`;
-        try {
-            if (!mongoose.connection.readyState) {
-                await mongoose.connect(dbUri, {
-                    autoIndex: true,
-                    dbName
-                });
-            }
-            else if (mongoose.connection.name !== dbName) {
-                await mongoose.disconnect();
-                await mongoose.connect(dbUri, {
-                    autoIndex: true,
-                    dbName
-                });
-            }
-            console.log('connected to db', `${dbName}`);
-            next();
-        }
-        catch (error) {
-            /** @ts-ignore */
-            res.status(500).send(`Failed to connect to database ${dbName}: ${error.message}`);
-        }
-    }
-}
-DBaseManager.port = 27017;
-// i can call it as a normal class or as a singleton
-export default DBaseManager.getInstance();
-export { DBaseManager as DatabaseManager, defaultDbName };

package/dist/engine/DBaseService.d.ts

@@ -1,16 +0,0 @@
-import { Document } from 'mongoose';
-import { type RequestParams } from './types';
-declare class DBaseService {
-    private model;
-    constructor(collection: string);
-    create(document: any): Promise<Document>;
-    findAll(params: RequestParams): Promise<Document[]>;
-    findById(id: string): Promise<Document | null>;
-    findOne(params: RequestParams): Promise<Document | null>;
-    deleteById(id: string): Promise<Document | null>;
-    deleteManyByQuery(params: RequestParams): Promise<{
-        deletedCount?: number;
-    }>;
-    decodeUrlParams(urlParams: string): RequestParams;
-}
-export default DBaseService;

package/dist/engine/DBaseService.js

@@ -1,48 +0,0 @@
-import { Model, Document } from 'mongoose';
-import { getModel } from './tools';
-import {} from './types';
-class DBaseService {
-    constructor(collection) {
-        this.model = getModel(collection);
-    }
-    async create(document) {
-        const newDocument = new this.model(document);
-        return newDocument.save();
-    }
-    async findAll(params) {
-        const sortOptions = {};
-        if (params.sortBy) {
-            const sortFields = params.sortBy.split(',');
-            sortFields.forEach((field) => {
-                const [key, order] = field.split(':');
-                sortOptions[key] = order === 'desc' ? -1 : 1;
-            });
-        }
-        return this.model.find().sort(sortOptions);
-    }
-    async findById(id) {
-        return this.model.findById(id);
-    }
-    async findOne(params) {
-        return this.model.findOne(params.query);
-    }
-    async deleteById(id) {
-        return this.model.findByIdAndDelete(id);
-    }
-    async deleteManyByQuery(params) {
-        return this.model.deleteMany(params.query);
-    }
-    decodeUrlParams(urlParams) {
-        const params = {};
-        const urlParamsArray = urlParams.split('&');
-        urlParamsArray.forEach((param) => {
-            const [key, value] = param.split('=');
-            if (key && value) {
-                /** @ts-ignore */
-                params[key] = JSON.parse(decodeURIComponent(value));
-            }
-        });
-        return params;
-    }
-}
-export default DBaseService;

package/dist/engine/tools.d.ts

@@ -1,2 +0,0 @@
-import { Document, Model } from 'mongoose';
-export declare const getModel: (collectionName: string) => Model<Document>;

package/dist/engine/tools.js

@@ -1,11 +0,0 @@
-import mongoose, { Schema, Document, Model } from 'mongoose';
-import AutoIncrementFactory from 'mongoose-sequence';
-const AutoIncrement = AutoIncrementFactory(mongoose);
-export const getModel = (collectionName) => {
-    if (mongoose.models[collectionName]) {
-        return mongoose.models[collectionName];
-    }
-    const schema = new Schema({}, { strict: false });
-    schema.plugin(AutoIncrement, { inc_field: 'idFieldName' });
-    return mongoose.model(collectionName, schema, collectionName);
-};

package/dist/engine/types.d.ts

@@ -1,9 +0,0 @@
-export interface RequestParams {
-    id?: string;
-    query?: any;
-    sortBy?: string;
-    body?: any;
-}
-export interface SortOptions {
-    [key: string]: 1 | -1;
-}