@medyll/idae-api 0.0.1

package/dist/ApiServe.d.ts

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

package/dist/ApiServe.js

@@ -0,0 +1,113 @@
+// 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, mdbPort = 27017, mdbName = 'idae') {
+        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

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

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

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

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

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

package/dist/engine/tools.js

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

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

package/dist/engine/types.js

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

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { ApiServe } from './ApiServe.js';

package/dist/index.js

@@ -0,0 +1,2 @@
+// Reexport your entry components here
+export { ApiServe } from './ApiServe.js';

package/package.json

@@ -0,0 +1,62 @@
+{
+	"name": "@medyll/idae-api",
+	"scope": "@medyll",
+	"version": "0.0.1",
+	"scripts": {
+		"dev": "vite dev",
+		"build": "vite build && npm run package",
+		"preview": "vite preview",
+		"package": "svelte-kit sync && svelte-package && publint",
+		"prepublishOnly": "npm run package",
+		"check": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json",
+		"check:watch": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json --watch",
+		"test": "vitest",
+		"lint": "prettier --check . && eslint .",
+		"format": "prettier --write ."
+	},
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"svelte": "./dist/index.js"
+		}
+	},
+	"files": [
+		"dist",
+		"!dist/**/*.test.*",
+		"!dist/**/*.spec.*"
+	],
+	"dependencies": {
+		"express": "^4.19.2",
+		"mongoose-sequence": "^6.0.1"
+	},
+	"peerDependencies": {
+		"svelte": "^4.0.0 || ^5.0.0"
+	},
+	"devDependencies": {
+		"@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",
+		"@types/express": "^4.17.21",
+		"@types/mongoose": "^5.11.97",
+		"eslint": "^9.0.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",
+		"svelte": "^5.0.0-next.181",
+		"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": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"type": "module"
+}