mosquito-transport 1.4.3 → 1.4.6

package/README.md

@@ -2,42 +2,36 @@
 
 MosquitoTransport is a powerful tool that enables developers to persist and synchronize data between their MongoDB database and frontend applications. It offers a centralized and self-hosted solution for managing server infrastructure and data, along with robust authentication, real-time data updates, scalability, and cross-platform compatibility.
 
-Under the hood, mosquito-transport uses Mongodb to store it data and [express](https://www.npmjs.com/package/express), [socket.io](https://www.npmjs.com/package/socket.io) for making request and [jwt](https://www.npmjs.com/package/jsonwebtoken) for signing authentication token, so make sure you have [mongodb](https://www.mongodb.com/docs/manual/installation/) installed before using this package.
+Under the hood, mosquito-transport uses Mongodb to store it data, along with [express](https://www.npmjs.com/package/express), [socket.io](https://www.npmjs.com/package/socket.io) for making request and [jwt](https://www.npmjs.com/package/jsonwebtoken) for signing authentication token, so make sure you have [mongodb](https://www.mongodb.com/docs/manual/installation/) installed before using this package.
 
 ## Key features of mosquito-transport include:
 
-- ### Data Persistence and Synchronization 🔁: 
+- Data Persistence and Synchronization 🔁: 
     - Seamlessly persist and synchronize data between MongoDB and frontend applications, ensuring consistency across all clients.
-
-- ### Self-Hosted Server 💾: 
+- Self-Hosted Server 💾: 
     - Host your own server infrastructure, giving you full control over data storage, access, and management.
-
-- ### User Authentication and Authorization 🔐:
+- User Authentication and Authorization 🔐:
     - Easily implement user authentication and authorization using JWT (JSON Web Tokens), providing secure access control to your application's resources.
-
-- ### End-to-End Encryption 🔗:
+- End-to-End Encryption 🔗:
     - Optionally enforce end-to-end encryption by allowing only encrypted data to be transmitted between client and server, ensuring data privacy and security.
-
-- ### Real-Time Data Updates 🚨:
+- Real-Time Data Updates 🚨:
     - Enable real-time updates to keep data synchronized across all clients in real-time, providing a seamless user experience.
-
-- ### Scalability and Performance 🚛:
+- Scalability and Performance 🚛:
     - Benefit from auto-scaling and high performance, allowing your application to handle varying workloads with ease.
-
-- ### Cross-Platform Compatibility 📱:
+- Cross-Platform Compatibility 📱:
     - Compatible with React Native and web applications, allowing you to build cross-platform solutions with ease.
 
 
 ## Installation
 
 ```sh
-npm install mosquito-transport
+npm install mosquito-transport mongodb --save
 ```
 
 or using yarn
 
 ```sh
-yarn add mosquito-transport
+yarn add mosquito-transport mongodb
 ```
 
 ## Usage
@@ -47,15 +41,12 @@ import MosquitoTransportServer from "mosquito-transport";
 import { MongoClient } from 'mongodb';
 
 // create a mongodb instance
-const dbInstance = new MongoClient('mongodb://127.0.0.1:27017', {
-    useNewUrlParser: true,
-    useUnifiedTopology: true
-});
+const dbInstance = new MongoClient('mongodb://127.0.0.1:27017');
 
 dbInstance.connect().then(() => {
-    console.log('connected to mongodb at');
+    console.log('connected to mongodb');
 }).catch(e => {
-    console.error('failed to connected to mongodb at');
+    console.error('failed to connected to mongodb');
 });
 
 // setup your server
@@ -63,7 +54,8 @@ const serverApp = new MosquitoTransportServer({
   projectName: 'app_name',
   port: 4534, // defaults to 4291
   signerKey: 'random_90_hash_key_for_signing_jwt_tokens', // must be 90 length
-  accessKey: 'this_is_my_private_password', // keep this private if you don't provide databaseRules or storageRules
+  accessKey: 'some_unique_string',
+  externalAddress: 'https://example.yourdomain.com',
   mongoInstances: {
       // this is where user info and tokens is stored
       admin: {
@@ -105,13 +97,72 @@ your server is now ready to be deploy on node.js! 🚀. Now install any mosquito
 ### SDKs And Hacks
 - [react-native-mosquito-transport](https://github.com/deflexable/react-native-mosquito-transport) for react native apps
 - [mosquito-transport-web](https://github.com/brainbehindx/mosquito-transport-js) for web platform
-- [mongodb-hack-middleware](https://github.com/deflexable/mongodb-middleware-utils) for random query hack and fulltext search hack
+- [mongodb-hack-middleware](https://github.com/deflexable/mongodb-middleware-utils) for querying random document hack and fulltext search hack
 
 ## Additional Documentations
-- [Logging Level](#logging-levels)
-- [Database Rules](#database-rules)
-- [Storage Rules](#storage-rules)
-- [Authentication](#authentication)
+- [MosquitoTransportServer Constructor](#MosquitoServerConfig)
+   - [projectName](#projectName)
+   - [signerKey](#signerKey)
+   - [port](#port)
+   - [storageRules](#storageRules)
+   - [databaseRules](#databaseRules)
+   - [accessTokenInterval](#accessTokenInterval)
+   - [refreshTokenExpiry](#refreshTokenExpiry)
+   - [accessKey](#accessKey)
+   - [mongoInstances](#mongoInstances)
+   - [externalAddress](#externalAddress)
+   - [hostname](#hostname)
+   - [enableSequentialUid](#enableSequentialUid)
+   - [mergeAuthAccount](#mergeAuthAccount)
+   - [sneakSignupAuth](#sneakSignupAuth)
+   - [uidLength](#uidLength)
+   - [enforceE2E](#enforceE2E)
+   - [e2eKeyPair](#e2eKeyPair)
+   - [logger](#logger)
+   - [dumpsterPath](#dumpsterPath)
+   - [preMiddlewares](#preMiddlewares)
+   - [transformMediaRoute](#transformMediaRoute)
+   - [transformMediaCleanupTimeout](#transformMediaCleanupTimeout)
+   <!-- - [googleAuthConfig](#googleAuthConfig)
+   - [appleAuthConfig](#appleAuthConfig)
+   - [facebookAuthConfig](#facebookAuthConfig)
+   - [githubAuthConfig](#githubAuthConfig)
+   - [twitterAuthConfig](#twitterAuthConfig)
+   - [fallbackAuthConfig](#fallbackAuthConfig) -->
+   - [staticContentProps](#staticContentProps)
+   - [staticContentMaxAge](#staticContentMaxAge)
+   - [staticContentCacheControl](#staticContentCacheControl)
+   - [corsOrigin](#corsOrigin)
+   - [maxRequestBufferSize](#maxRequestBufferSize)
+   - [maxUploadBufferSize](#maxUploadBufferSize)
+- [MosquitoTransportServer Getters](#MosquitoTransportServer-Getters)
+   - [storagePath](#storagePath)
+   - [sampleE2E](#sampleE2E)
+   - [express](#express)
+- [MosquitoTransportServer Methods](#MosquitoTransportServer-Methods)
+   - [getDatabase](#getDatabase)
+   - [listenDatabase](#listenDatabase)
+   - [listenStorage](#listenStorage)
+   - [listenHttpsRequest](#listenHttpsRequest)
+   - [listenNewUser](#listenNewUser)
+   - [listenDeletedUser](#listenDeletedUser)
+   - [verifyToken](#verifyToken)
+   - [validateToken](#validateToken)
+   - [invalidateToken](#invalidateToken)
+   - [getUserData](#getUserData)
+   - [updateUserProfile](#updateUserProfile)
+   - [updateUserClaims](#updateUserClaims)
+   - [updateUserEmailAddress](#updateUserEmailAddress)
+   - [updateUserPassword](#updateUserPassword)
+   - [updateUserEmailVerify](#updateUserEmailVerify)
+   - [signOutUser](#signOutUser)
+   - [disableUser](#disableUser)
+   - [uploadBuffer](#uploadBuffer)
+   - [deleteFile](#deleteFile)
+   - [deleteFolder](#deleteFolder)
+   - [inspectDocDisconnectionTask](#inspectDocDisconnectionTask)
+   - [linkToFile](#linkToFile)
+- [Authentication Setup](#authentication-setup)
    - [Merge Auth Account](#google-auth-setup)
    - [Google Auth Setup](#google-auth-setup)
    - [Apple Auth Setup](#apple-auth-setup)
@@ -122,6 +173,488 @@ your server is now ready to be deploy on node.js! 🚀. Now install any mosquito
    - [Google Auth Setup](#google-auth-setup)
 
 
+## MosquitoServerConfig
+
+### projectName
+
+the name for your mosquito-transport instance. this is required and used internally by both the backend and frontend client.
+
+### signerKey
+
+a 90 character string which is used in signing jwt access and refresh token.
+
+### port
+
+the port number you want mosquito-transport instance to be running on
+
+### storageRules
+
+a function used for securing all file operations (`uploadFile`, `downloadFile`, `deleteFile`, `deleteFolder`) made by the frontend client.
+<!-- TODO: show examples -->
+
+### databaseRules
+
+a function used for securing all mongodb read and write operations made by the frontend client.
+<!-- show examples -->
+
+### accessTokenInterval
+
+numbers of milliseconds until generated access token expires. Defaults to `1 hour` (3600000).
+
+### refreshTokenExpiry
+
+numbers of milliseconds until generated refresh token expires. Defaults to `1 month` (2419200000).
+
+### accessKey
+
+a random string used by the frontend client for accessing internal resources.
+
+### mongoInstances
+
+an object that maps names to your mongodb instance. if no `dbRef` were provided, the `default` mongodb instance will be used.
+
+```js
+import MosquitoTransportServer from "mosquito-transport";
+import { MongoClient } from 'mongodb';
+
+// create a mongodb instance
+const dbInstance = new MongoClient('mongodb://127.0.0.1:27017');
+
+dbInstance.connect();
+
+const remoteInstance = new MongoClient('mongodb://other-searver.com');
+
+remoteInstance.connect();
+
+const serverApp = new MosquitoTransportServer({
+  ...otherProps,
+  mongoInstances: {
+      // frontend client are prohitted from accessing this instance
+      admin: {
+          instance: dbInstance,
+          defaultName: 'ADMIN_DB_NAME'
+      },
+      // this will be the default db if no dbRef was provided by the frontend client
+      default: {
+          instance: dbInstance,
+          defaultName: 'DEFAULT_DB_NAME'
+      },
+      // additional instance
+      remoteBackup: {
+           instance: remoteInstance,
+          defaultName: 'WEB_BACKUP'
+      }
+  }
+});
+
+// then you can access this via frontend client
+
+const webInstance = new MosquitoTransport({
+    projectUrl: 'http://localhost:4534/app_name',
+    accessKey: 'some_unique_string',
+    ...options
+});
+
+webInstance.getDatabase(
+    // if this is undefined, the server will use `defaultName` as the default name
+    'database_name',
+    // the name of the mongoInstances map
+    'remoteBackup'
+).collection('transactions').findOne({ date: { $gt: 1719291129937 } }).get();
+
+// or access the default db
+
+webInstance.getDatabase().collection('testing');
+
+```
+
+### externalAddress
+
+this should be a valid http or https link. it is used internally while signing jwt and for prefixing storage `downloadUrl` when uploading a file by frontend client.
+
+### hostname
+
+if no `externalAddress` was provided, `externalAddress` will be a construct as follows:
+
+```js
+`http://${hostname || 'localhost'}:${port}`
+```
+
+### enableSequentialUid
+
+true if you want new users to be assign a sequential `uid` like 0, 1, 2, 3, 4, 5, ...,
+
+### mergeAuthAccount
+
+true if you want to threat the same email address from different auth provider as a single user.
+
+### sneakSignupAuth
+
+a function use in preventing signup and adding metadata before signup
+
+```js
+import MosquitoTransportServer from "mosquito-transport";
+
+const blacklisted_country = ['RU', 'AF', 'NG'];
+
+const serverApp = new MosquitoTransportServer({
+    ...otherProps,
+    sneakSignupAuth: ({ request, email, name, password, method }) => {
+        const geo = lookupIpAddress(request.ip);
+        if (!geo) throw 'Failed to lookup request location';
+
+        if (blacklisted_country.includes(geo.country))
+            throw 'This platform is not yet available in your location';
+        
+        if (method === 'custom' && password.length < 5)
+            throw 'password is too short';
+
+        const uid = randomString(11),
+            lang = getCountryLang(geo?.country || 'US');
+
+        return {
+            metadata: {
+                country: geo.country,
+                city: geo.city,
+                location: geo.ll,
+                tz: geo?.timezone,
+                ip: request.ip,
+                locale: 'en'
+            },
+            uid
+        };
+    }
+});
+```
+
+### uidLength
+
+the length of generated user uid. default to `30`.
+
+### enforceE2E
+
+true if you want to enforce end-to-end encryption for all request made by the server
+
+### e2eKeyPair
+
+an array of string, `[public key, private key]`. You can get a sample as follows:
+
+```js
+import MosquitoTransportServer from "mosquito-transport";
+
+const serverApp = new MosquitoTransportServer({ ...options });
+
+console.log('pair key', serverApp.sampleE2E);
+```
+### dumpsterPath
+
+path to where mosquito-transport stores it files. Defaults to the current working directory.
+
+### preMiddlewares
+
+a function to intercept express. This will be the first middleware executed by express.
+
+```js
+import MosquitoTransportServer from "mosquito-transport";
+
+const serverApp = new MosquitoTransportServer({
+    ...otherProps,
+    preMiddlewares: (req, res, next) => {
+        // do some enforcement checking here
+        next();
+    } 
+});
+```
+
+### transformMediaRoute
+
+this option helps you to transform image and video files on the fly without having to write boilerplate code for this.
+All you have to do is set `transformMediaRoute` to `*` as follows:
+
+```js
+import MosquitoTransportServer from "mosquito-transport";
+
+const serverApp = new MosquitoTransportServer({
+    ...otherProps,
+    transformMediaRoute: '*'
+});
+```
+
+now you can automatically transform images and video by appending some query parameter to the url of the image or video you're accessing.
+
+#### Image Parameters
+the following list the parameters available for image media
+
+- `width` or `w`: a number that sets the width of the image
+- `height` or `h`: a number that sets the height of the image
+- `top` or `t`: a number that sets the top position of the image
+- `left` or `l`: a number that sets the left position of the image
+- `grayscale`or `gray`: set this to `1` or `true` if you want the image in grayscale
+-  `blur` or `b`: either set this to `true` to blur the image or a value between 0.3 and 1000 representing the sigma of the Gaussian mask, where sigma = 1 + radius / 2.
+- `flip`: set to `true` or `1` to flip the image about the vertical Y axis. The use of flip implies the removal of the EXIF Orientation tag, if any.
+- `flop`: set to `true` or `1` to flop the image about the horizontal X axis. The use of flop implies the removal of the EXIF Orientation tag, if any.
+- `format` or `o`: this set the output format of the image, can be any of `avif`, `dz`, `fits`, `gif`, `heif`, `input`, `jpeg`, `jpg`, `jp2`, `jxl`, `magick`, `openslide`, `pdf`, `png`, `ppm`, `raw`, `svg`, `tiff`, `tif`, `v` or `webp`
+- `quality` or `q`: set the quality of the image from a scale of 0 - 1.
+- `lossless` or `loss`: set to `1` or `true` to use lossless compression mode
+
+***Example***
+the following transform the image at `http://localhost:5622/storage/users/richard/photo.png`:
+
+```js
+// resize the image to 70 width and scale the height respectively
+`http://localhost:5622/storage/users/richard/photo.png?w=70`
+
+// apply grayscale to the image and set the quality to 0.3
+`http://localhost:5622/storage/users/richard/photo.png?grayscale=true&q=0.3`
+```
+
+#### Video Parameters
+the following list the parameters available for video media
+
+- `width` or `w`: a number that sets the width of the video.
+- `height` or `h`: a number that sets the height of the video.
+- `top` or `t`: a number that sets the top position of the video.
+- `left` or `l`: a number that sets the left position of the video.
+- `mute`: set to `1` or `true` to mute the video.
+- `vbr`: set the bitrate of the video. Equivalent to `-v:a` command of ffmpeg.
+- `abr`: set the bitrate of the audio. Equivalent to `-b:a` command of ffmpeg.
+- `fps`: an integer to set the frame per seconds of the video. This parameter plays a significant role in reducing the output size and processing time of the video. Equivalent to `-r` command of ffmpeg.
+- `grayscale`or `gray`: set this to `1` or `true` if you want the video in grayscale
+- `flip`: set to `true` or `1` to flip the video about the vertical Y axis.
+- `flop`: set to `true` or `1` to flop the video about the horizontal X axis.
+- `quality` or `q`: set the quality of the video from a scale of 0 - 1.
+- `lossless` or `loss`: set to `1` or `true` to use lossless compression mode
+- `preset`: set the `-preset` of ffmpeg. Defaults to medium.
+- `format` or `o`: this set the output format of the image, can be any of `avif`, `dz`, `fits`, `gif`, `heif`, `input`, `jpeg`, `jpg`, `jp2`, `jxl`, `magick`, `openslide`, `pdf`, `png`, `ppm`, `raw`, `svg`, `tiff`, `tif`, `v` or `webp`
+
+***Example***
+the following transform the video at `http://localhost:5622/storage/video/lil-yatchy/range-rover-sport-truck.mp4`:
+
+```js
+// resize the video to 200 height and scale the width respectively
+`http://localhost:5622/storage/video/lil-yatchy/range-rover-sport-truck.mp4?height=200`
+
+// apply grayscale to the video, set the quality to 0.7 and set the fps to 30
+`http://localhost:5622/storage/video/lil-yatchy/range-rover-sport-truck.mp4?grayscale=true&q=0.7&fps=30`
+```
+***Additional Dependency***
+Internally mosquito-transport uses `sharp` to transform images and `ffmpeg` to transform video, so make sure these library are installed before setting `transformMediaRoute: '*'`
+
+```sh
+yarn add sharp
+```
+
+### transformMediaCleanupTimeout
+
+This is the numbers of milliseconds to cache the transformed video media file before it is deleted. This is basically to avoid the overhead processing time next time the frontend client tries to access it. Defaults to 7 hours.
+
+# logger
+
+can either be a string or array containing any of the following:
+
+- `all`: log all requests
+- `auth`: log authentication requests
+- `database`: log database requests
+- `storage`: log storage requests
+- `external-requests`: log api requests
+- `served-content`: log serve content requests
+- `database-snapshot`: log database snapshot events
+
+### staticContentProps
+
+Static Content Props for storage file response. See [SendFileOptions](https://github.com/expressjs/expressjs/express-serve-static-core/index.d.ts)
+
+### staticContentMaxAge
+
+Provide a max-age in milliseconds for http caching. This will only be applied to storage file response.
+
+### staticContentCacheControl
+
+Enable or disable setting Cache-Control response header. This will only be applied to storage file response.
+
+### corsOrigin
+
+set cors origin for all outgoing request
+
+### maxRequestBufferSize
+
+the maximum size in bytes of each request payload. Default to 100MB
+
+### maxUploadBufferSize
+
+the maximum size in byte of each uploading request payload. Default to 10GB
+
+## MosquitoTransportServer-Getters
+
+### storagePath
+
+get the directory where storage files are saved
+
+### sampleE2E
+
+quickly get an end-to-end encryption [pair key](#[e2eKeyPair]) for your server
+
+### express
+
+get the internal express instance use
+
+## MosquitoTransportServer-Methods
+
+### getDatabase
+
+returns the db instance of mongodb.
+
+```js
+serverApp.getDatabase(
+    // if this is undefined, the server will use `defaultName` as the default name
+    'database_name',
+    // the name of the mongoInstances map
+    'remoteBackup'
+).collection('transactions').findOne({ date: { $gt: 1719291129937 } }).get();
+
+// or access the default db
+
+serverApp.getDatabase().collection('testing');
+```
+
+### listenDatabase
+
+listen to insert, update and delete events from mongodb
+
+```js
+serverApp.listenDatabase('transactions', async snapshot => {
+    console.log('transaction snapshot', snapshot);
+});
+```
+
+### listenStorage
+
+listen to storage event. these event are typically made by the frontend client.
+
+```js
+serverApp.listenStorage(async event => {
+    console.log('storage event', event);
+});
+```
+
+### listenHttpsRequest
+
+listen to incoming request
+
+```js
+// only allow authenticated user to access this endpoint 
+serverApp.listenHttpsRequest('check_user', async (req, res, user) => {
+    // user will always be present
+    res.status(200).send({ uid: user.uid });
+}, {
+    enforceVerifiedUser: true,
+    enforceUser: true
+});
+
+// optionally allow un-authenticated user
+serverApp.listenHttpsRequest('server_time', async (req, res, user) => {
+    // user may be present
+    if (user) {
+        res.status(200).send({ uid: user.uid });
+    } else {
+        res.status(403).send({ error: 'No user provided' });
+    }
+}, {
+    validateUser: true
+});
+
+// disable end-to-end encrytion for this endpoint and user authentication
+serverApp.listenHttpsRequest('server_time', async (req, res) => {
+    res.status(200).send({ currentData: Date.now() });
+}, {
+    rawEntry: true
+});
+```
+
+### listenNewUser
+
+listen to new user
+
+```js
+serverApp.listenNewUser(async user => {
+    console.log('new signup', user);
+});
+```
+
+### listenDeletedUser
+
+listen to deletedUser
+
+```js
+serverApp.listenDeletedUser(uid => {
+    console.log('deleted user', uid);
+});
+```
+
+### verifyToken
+
+verify token to check if it was trully created using signerKey without checking against the expiry or local token reference
+
+### validateToken
+
+verify token to check if it was trully created using signerKey and checking against the expiry and local token reference
+
+### invalidateToken
+
+remove local reference of a token
+
+### getUserData
+
+get the user data belonging to a user
+
+### updateUserProfile
+
+update the profile data of a user
+
+### updateUserClaims
+
+update the custom claim of a user
+
+### updateUserEmailAddress
+
+update the email address of a user
+
+### updateUserPassword
+
+update the user password of a user
+
+### updateUserEmailVerify
+
+update the verify status of a user
+
+### signOutUser
+
+purge all tokens references for a user and sign-out the user immediately
+
+### disableUser
+
+disable a user
+
+### uploadBuffer
+
+upload a file to the storage directory
+
+### deleteFile
+
+delete file in the storage directory
+
+### deleteFolder
+
+delete folder in the storage directory
+
+### linkToFile
+
+convert a link to local file path.
+
+```js
+serverApp.linkToFile('http://localhost:5622/storage/users/richard/photo.png');
+```
+
 <!-- ## Platform using MosquitoTransport in production
 - [Heavenya - christian events](https://heavenya.com)
 - [Inspire - christian audio](https://inspire.com)

package/TODO

@@ -0,0 +1,2 @@
+- add method for creating user account
+- add method for login user account

package/lib/helpers/listeners.js

@@ -2,4 +2,5 @@ import SubscriptionListener from "subscription-listener";
 
 export const StorageListener = new SubscriptionListener();
 export const DisconnectionWriteTaskListener = new SubscriptionListener();
-export const UserCountReadyListener = new SubscriptionListener();;
+export const UserCountReadyListener = new SubscriptionListener();
+export const SignoutUserSignal = new SubscriptionListener();

package/lib/helpers/utils.js

@@ -53,7 +53,7 @@ export const deserializeE2E = (data, projectName) => {
         const [clientPubKey, clientNonce, clientData] = data.split('.'),
             [_, serverPrivateKey] = Scoped.InstancesData[projectName].E2E_BufferPair || [];
 
-        if (serverPrivateKey) throw '"e2eKeyPair" is required for decrypting a e2e messages';
+        if (!serverPrivateKey) throw '"e2eKeyPair" is required for decrypting a e2e messages';
         const baseArray = box.open(
             Buffer.from(clientData, 'base64'),
             Buffer.from(clientNonce, 'base64'),

package/lib/helpers/values.js

@@ -59,7 +59,6 @@ export const EngineRoutes = {
     _twitterSignin: '_twitterSignin',
     _githubSignin: '_githubSignin',
     _signOut: '_signOut',
-    _invalidateToken: '_invalidateToken',
     _uploadFile: '_uploadFile',
     _deleteFile: '_deleteFile',
     _deleteFolder: '_deleteFolder',

package/lib/index.d.ts

@@ -1,4 +1,4 @@
-import { Auth, Db, Document, MongoClient, SortDirection, UpdateDescription } from "mongodb";
+import { Db, Document, MongoClient, SortDirection, UpdateDescription } from "mongodb";
 import express from "express";
 import { CorsOptions } from "cors";
 import { Sort } from "mongodb";
@@ -50,10 +50,10 @@ interface DatabaseRulesSnapshot {
     endpoint: '_readDocument' | '_queryCollection' | '_writeDocument' | '_writeMapDocument' | '_documentCount' | '_listenCollection' | '_listenDocument' | '_startDisconnectWriteTask' | '_cancelDisconnectWriteTask';
     prescription?: DatabaseRulesIOPrescription | DatabaseRulesBatchWritePrescription;
     dbName?: string;
-    dbUrl?: string;
+    dbRef?: string;
 }
 
-type LogLevel = 'all' | 'disabled' | 'auth' | 'database' | 'storage' | 'external-requests' | 'served-content' | 'database-snapshot';
+type LogLevel = 'all' | 'auth' | 'database' | 'storage' | 'external-requests' | 'served-content' | 'database-snapshot';
 
 interface GoogleAuthConfig {
     clientID?: string;
@@ -223,6 +223,8 @@ interface MSocketHandshake {
     };
     /**
      * the access token of the user that initiated this handshake
+     * 
+     * N/B: make sure to always revalidate this when making sensitive request
      */
     userToken: string | undefined;
 }
@@ -251,7 +253,7 @@ interface TransformMediaOption {
 
 interface TransformMediaRoute {
     route: typeof RegExp | string;
-    type?: string;
+    transformAs?: 'image' | 'video';
     transform: (options: TransformMediaOption) => Buffer | string | null | undefined;
 }
 
@@ -265,21 +267,155 @@ interface MongoInstancesMap {
 }
 
 interface MosquitoServerConfig {
+    /**
+     * the name for your mosquito-transport instance. this is required and used internally by both the backend and frontend client
+     */
     projectName: string;
+    /**
+     * a 90 character string which is used in signing jwt access and refresh token
+     */
     signerKey: string;
+
     storageRules: (snapshot?: StorageRulesSnapshot) => Promise<void> | undefined;
     databaseRules: (snapshot?: DatabaseRulesSnapshot) => Promise<void> | undefined;
     onSocketSnapshot?: (snapshot?: MSocketSnapshot, error?: MSocketError) => void;
+    /**
+     * the port number you want mosquito-transport instance to be running on
+     */
     port?: number;
+    /**
+     * true if you want new users to be assign a sequential `uid` like 0, 1, 2, 3, 4, 5, ...,
+     * 
+     * Please note: this is an experimental feature
+     */
     enableSequentialUid?: boolean;
+    /**
+     * a random string used by the frontend client for accessing internal resources
+     */
     accessKey: string;
+    /**
+     * can either be a string or array containing any of the following:
+     * 
+     * - `all`: log all requests
+     * - `auth`: log authentication requests
+     * - `database`: log database requests
+     * - `storage`: log storage requests
+     * - `external-requests`: log api requests
+     * - `served-content`: log serve content requests
+     * - `database-snapshot`: log database snapshot events
+     */
     logger?: LogLevel | LogLevel[];
+    /**
+     * this should be a valid http or https link. it is used internally while signing jwt and for prefixing storage `downloadUrl` when uploading a file by frontend client
+     */
     externalAddress?: string;
+    /**
+     * if no `externalAddress` was provided, `externalAddress` will be a construct as follows:
+     * 
+     * ```js
+     * `http://${hostname || 'localhost'}:${port}`
+     * ```
+     */
     hostname?: string;
+    /**
+     * an object that maps names to your mongodb instance. if no `dbRef` were provided, the `default` mongodb instance will be used.
+     * 
+     * ```js
+     * import MosquitoTransportServer from "mosquito-transport";
+     * import { MongoClient } from 'mongodb';
+     * 
+     * // create a mongodb instance
+     * const dbInstance = new MongoClient('mongodb://127.0.0.1:27017');
+     * dbInstance.connect();
+     * 
+     * const remoteInstance = new MongoClient('mongodb://other-searver.com');
+     * remoteInstance.connect();
+     * 
+     * const serverApp = new MosquitoTransportServer({
+     *   ...otherProps,
+     *   mongoInstances: {
+     *     // frontend client are prohitted from accessing this instance
+     *     admin: {
+     *        instance: dbInstance,
+     *        defaultName: 'ADMIN_DB_NAME'
+     *     },
+     *     // this will be the default db if no dbRef was provided by the frontend client
+     *     default: {
+     *        instance: dbInstance,
+     *        defaultName: 'DEFAULT_DB_NAME'
+     *     },
+     *     // additional instance
+     *     remoteBackup: {
+     *         instance: remoteInstance,
+     *        defaultName: 'WEB_BACKUP'
+     *     }
+     *   }
+     * });
+     * 
+     * // then you can access this via frontend client
+     * 
+     * const webInstance = new MosquitoTransport({
+     *   projectUrl: 'http://localhost:4534/app_name',
+     *   accessKey: 'some_unique_string',
+     *   ...options
+     * });
+     * 
+     * webInstance.getDatabase(
+     *   // if this is undefined, the server will use `defaultName` as the default name
+     *   'database_name',
+     *   // the name of the mongoInstances map
+     *   'remoteBackup'
+     * ).collection('transactions').findOne({ date: { $gt: 1719291129937 } }).get();
+     * 
+     * // or access the default db
+     * 
+     * webInstance.getDatabase().collection('testing');
+     * ```
+     */
     mongoInstances: MongoInstancesMap;
+    /**
+     * true if you want to threat the same email address from different auth provider as a single user
+     */
     mergeAuthAccount?: boolean;
     transformMediaRoute?: '*' | TransformMediaRoute[];
-    transformMediaCleanupTimeout?: string;
+    /**
+     * This is the numbers of milliseconds to cache the transformed video media file before it is deleted. This is basically to avoid the overhead processing time next time the frontend client tries to access it. Defaults to 7 hours.
+     */
+    transformMediaCleanupTimeout?: number;
+    /**
+     * 
+     * a function use in preventing signup and adding metadata before signup
+     * ```js
+     * import MosquitoTransportServer from "mosquito-transport";
+     * const blacklisted_country = ['RU', 'AF', 'NG'];
+     * 
+     * const serverApp = new MosquitoTransportServer({
+     *     ...otherProps,
+     *     sneakSignupAuth: ({ request, email, name, password, method }) => {
+     *         const geo = lookupIpAddress(request.ip);
+     *         if (!geo) throw 'Failed to lookup request location';
+     *         if (blacklisted_country.includes(geo.country))
+     *             throw 'This platform is not yet available in your location';
+     *         
+     *         if (method === 'custom' && password.length < 5)
+     *             throw 'password is too short';
+     *         const uid = randomString(11),
+     *             lang = getCountryLang(geo?.country || 'US');
+     *         return {
+     *             metadata: {
+     *                 country: geo.country,
+     *                 city: geo.city,
+     *                 location: geo.ll,
+     *                 tz: geo?.timezone,
+     *                 ip: request.ip,
+     *                 locale: 'en'
+     *             },
+     *             uid
+     *         };
+     *     }
+     * });
+     * ```
+     */
     sneakSignupAuth?: (config: SneakSignupAuthConfig) => SneakSignupAuthResult;
     googleAuthConfig?: GoogleAuthConfig;
     appleAuthConfig?: AppleAuthConfig;
@@ -297,9 +433,13 @@ interface MosquitoServerConfig {
     accessTokenInterval?: number;
     refreshTokenExpiry?: number;
     dumpsterPath?: string;
+    /**
+     * require an e2e public and private key like:
+     * `['public key', 'private key']`
+     */
     e2eKeyPair?: string[] | undefined;
     enforceE2E?: boolean;
-    preMiddlewares?: Function[] | Function;
+    preMiddlewares?: express.Handler | express.Handler[];
 }
 
 interface UserProfile {
@@ -378,7 +518,7 @@ interface DisconnectTaskInspector extends SimpleError {
     task?: ({
         commands: WriteCommand;
         dbName?: string;
-        dbUrl?: string;
+        dbRef?: string;
     })
 }
 
@@ -394,10 +534,29 @@ interface RawBodyRequest extends express.Request {
     rawBody: Buffer;
 }
 
-export default class MosquitoDbServer {
+export default class MosquitoTransportServer {
     constructor(config: MosquitoServerConfig);
 
-    getDatabase(dbName?: string, dbUrl?: string): Db;
+    /**
+     * the directory where storage files are saved
+     */
+    get storagePath(): string;
+
+    /**
+     * quickly get an end-to-end encryption pair key for your server
+     * @returns [public_string, private_string]
+     */
+    get sampleE2E(): string[];
+
+    get express(): express.Application;
+
+    getDatabase(dbName?: string, dbRef?: string): Db;
+
+    /**
+     * purge all tokens references for a user and sign-out the user immediately
+     * @param uid uid of the user you are signing out
+     */
+    signOutUser(uid: string): Promise<void>;
 
     /**
      * verify token to check if it was trully created using signerKey without checking against the expiry or local token reference
@@ -422,6 +581,10 @@ export default class MosquitoDbServer {
      * @param isRefreshToken - set this to true if token is a refresh token
      */
     invalidateToken(token: string, isRefreshToken?: boolean): Promise<void | boolean>;
+
+    /**
+     * listen to incoming request
+     */
     listenHttpsRequest(route: string, callback?: (request: RawBodyRequest, response: express.Response, auth?: JWTAuthData | null) => void, options?: MosquitoDbHttpOptions): void;
     listenDatabase(collection: string, callback?: (data: DatabaseListenerCallbackData) => void, options?: DatabaseListenerOption): void;
     listenStorage(callback?: (snapshot: StorageSnapshot) => void): () => void;

package/lib/index.js

@@ -14,11 +14,11 @@ import { validateFacebookAuthConfig } from "./products/auth/facebookAuth.js";
 import { validateGithubAuthConfig } from "./products/auth/githubAuth.js";
 import { validateTwitterAuthConfig } from "./products/auth/twitterAuth.js";
 import { validateFallbackAuthConfig } from "./products/auth/fallbackAuth.js";
-import { DisconnectionWriteTaskListener, StorageListener, UserCountReadyListener } from "./helpers/listeners.js";
+import { DisconnectionWriteTaskListener, SignoutUserSignal, StorageListener, UserCountReadyListener } from "./helpers/listeners.js";
 import EnginePath from "./helpers/EnginePath.js";
 import { Server } from "socket.io";
 import http from 'http';
-import { mkdir, readFile, unlink, writeFile, rm as rmdir } from "fs/promises";
+import { mkdir, readFile, unlink, writeFile, rm } from "fs/promises";
 import { cleanUserToken } from "./products/auth/customAuth.js";
 import { invalidateToken } from "./products/auth/customAuth.js";
 import cors from 'cors';
@@ -26,6 +26,9 @@ import { parse, stringify } from 'json-buffer';
 import { exec } from "child_process";
 import { createRequire } from 'node:module';
 import { MongoClient } from "mongodb";
+import naclPkg from 'tweetnacl';
+
+const { sign: e2eSign } = naclPkg;
 
 const _require = createRequire(import.meta.url);
 
@@ -73,9 +76,8 @@ const serveStorage = ({
         }
 
         const routeTransformer = mediaRoute === '*' ||
-            (mediaRoute || []).find(({ route, type }) =>
-                (route instanceof RegExp ? route.test(cleanRoute) : cleanRoute.startsWith(route)) &&
-                (type === undefined || routeExtension === type)
+            (mediaRoute || []).find(({ route }) =>
+                (route instanceof RegExp ? route.test(cleanRoute) : cleanRoute.startsWith(route))
             ),
             linkRef = requestURL(req),
             filePath = STORAGE_URL_TO_FILE(linkRef.href, projectName),
@@ -102,6 +104,7 @@ const serveStorage = ({
             [['loss', 'lossless'], (v) => v === '1' || v === 'true' || undefined],
             [['vbr'], v => v],
             [['abr'], v => v],
+            [['fps'], v => isNaN(v * 1) ? undefined : v * 1],
             [['preset'], v => v]
         ].forEach(([paths, ext]) => {
             const v = paths.map(v => ext(linkRef.searchParams.get(v) || undefined)).filter(v =>
@@ -121,11 +124,14 @@ const serveStorage = ({
                     if (routeTransformer?.transform) {
                         rib = await routeTransformer.transform({ request: req, localBuffer });
                         if (res.headersSent) return;
-                    } else if ((mediaType === 'image' || mediaType === 'video') && Object.keys(partern).length) {
+                    } else if (
+                        (mediaType === 'image' || mediaType === 'video' || routeTransformer?.transformAs) &&
+                        Object.keys(partern).length
+                    ) {
                         // console.log('transforming partern:', partern);
-                        const { width, height, grayscale, blur, fit, top, left, flip, flop, format, quality, lossless, mute, vbr, abr, preset } = partern;
+                        const { width, height, grayscale, blur, fit, top, left, flip, flop, format, quality, lossless, mute, vbr, abr, preset, fps } = partern;
 
-                        if (mediaType === 'image') {
+                        if (mediaType === 'image' || routeTransformer?.transformAs === 'image') {
                             const SharpLib = _require('sharp');
                             let sharpInstance = SharpLib(localBuffer);
 
@@ -176,7 +182,7 @@ const serveStorage = ({
                                         inputFile: filePath
                                     };
 
-                                    const ffmpegCommad = `ffmpeg -i "${filePath}"${mute ? ' -an' : ''}${com.length ? ' -vf "' + com.join(', ') + '"' : ''}${mute ? '' : ' -c:a copy'}${crf}${vbr ? ' -b:v ' + vbr : ''}${abr ? ' -b:a' + abr : ''} -preset ${preset || 'medium'} "${outPath}"`;
+                                    const ffmpegCommad = `ffmpeg -i "${filePath}"${mute ? ' -an' : ''}${com.length ? ' -vf "' + com.join(', ') + '"' : ''}${mute ? '' : ' -c:a copy'}${crf}${vbr ? ' -b:v ' + vbr : ''}${abr ? ' -b:a' + abr : ''}${fps ? ' -r' + fps : ''} -preset ${preset || 'medium'} "${outPath}"`;
 
                                     exec(ffmpegCommad, async (err) => {
                                         if (!Scoped.cacheTranformVideoTimer[outPath]) {
@@ -193,7 +199,7 @@ const serveStorage = ({
                                                 clearTimeout(Scoped.cacheTranformVideoTimer[outPath].timer);
                                                 delete Scoped.cacheTranformVideoTimer[outPath];
                                                 await niceTry(() => unlink(outPath));
-                                            }, transformMediaCleanupTimeout || (one_hour / 2));
+                                            }, transformMediaCleanupTimeout || (one_hour * 7));
                                             resolve(outPath);
                                             Scoped.cacheTranformVideoTimer[outPath].processList?.map?.(([done]) => done(outPath));
                                             delete Scoped.cacheTranformVideoTimer[outPath].processing;
@@ -356,7 +362,18 @@ const useMosquitoServer = (app, config) => {
         authLiveRoutes({ ...config }).map(e => e(socket, scope));
         databaseLiveRoutes({ ...config }).map(e => e(socket, scope));
 
-        if (initAuthHandshake?._m_internal || !onSocketSnapshot) return;
+        if (initAuthHandshake?._m_internal || !onSocketSnapshot) {
+            if (initAuthHandshake?._from_base) {
+                const signoutSignal = SignoutUserSignal.listenTo('d', () => {
+                    socket.emit('_signal_signout');
+                });
+
+                socket.on('disconnect', () => {
+                    signoutSignal();
+                });
+            }
+            return;
+        }
         try {
             const { e2e, ugly, accessKey: ak } = initAuthHandshake;
 
@@ -555,7 +572,7 @@ export default class MosquitoTransportServer {
 
         (async () => {
             try {
-                await rmdir(`${STORAGE_PREFIX_PATH(this.projectName)}/.vid_freezer`, {
+                await rm(`${STORAGE_PREFIX_PATH(this.projectName)}/.vid_freezer`, {
                     recursive: true,
                     force: true
                 });
@@ -567,6 +584,28 @@ export default class MosquitoTransportServer {
     get storagePath() {
         return STORAGE_PATH(this.projectName);
     }
+
+    get sampleE2E() {
+        const keyPair = e2eSign.keyPair();
+        return [
+            keyPair.publicKey,
+            keyPair.secretKey
+        ].map(v => Buffer.from(v).toString('base64'));
+    }
+
+    get express() {
+        return Scoped.expressInstances[`${this.port}`];
+    }
+
+    signOutUser = async (uid) => {
+        const db = getDB(this.projectName, ADMIN_DB_NAME, ADMIN_DB_URL);
+        await Promise.all([
+            db.collection(EnginePath.refreshTokenStore).deleteMany({ uid }),
+            db.collection(EnginePath.tokenStore).deleteMany({ uid })
+        ]);
+        SignoutUserSignal.dispatch('d', uid);
+    }
+
     verifyToken = (token, isRefreshToken) => verifyJWT(token, this.projectName, isRefreshToken);
     validateToken = (token, isRefreshToken) => validateJWT(token, this.projectName, isRefreshToken);
     invalidateToken = (token, isRefreshToken) => invalidateToken(token, this.projectName, isRefreshToken);
@@ -720,7 +759,7 @@ export default class MosquitoTransportServer {
         path = `${STORAGE_PATH(this.projectName)}/${path}`;
 
         removeVideoFreezer(path, true);
-        await rmdir(path, {
+        await rm(path, {
             recursive: true,
             force: true
         });
@@ -865,7 +904,7 @@ export default class MosquitoTransportServer {
 }
 
 const projectNameWrongChar = ['/', '\\', '.', '$', '%', '#', '!', '*', '?'];
-const loggerOptions = ['all', 'disabled', 'auth', 'database', 'storage', 'outside-requests', 'content'];
+const loggerOptions = ['all', 'auth', 'database', 'storage', 'external-requests', 'served-content', 'database-snapshot'];
 
 const validateResizableMediaRoute = (v) => {
     if (v !== '*') {
@@ -873,10 +912,10 @@ const validateResizableMediaRoute = (v) => {
         v.forEach((v, i) => {
             if (!(v?.route instanceof RegExp) && typeof v?.route !== 'string')
                 throw `"transformMediaRoute" array at index ${i} expected "route" to be either RegularExpression or string but got ${v?.route}`;
-            if (v?.type !== undefined && typeof v?.type !== 'string')
-                throw `"transformMediaRoute" array at index ${i} expected "route" to be string`;
             if (v?.transform !== undefined && typeof v?.transform !== 'function')
                 throw `"transformMediaRoute" array at index ${i} expected "transform" to be a function`;
+            if (v?.transformAs !== undefined && v.transformAs !== 'image' && v.transformAs !== 'video')
+                throw `"transformAs" must be either "image" or "video" but got "${v.transformAs}"`;
         });
     }
 }

package/lib/products/auth/customAuth.js

@@ -203,7 +203,8 @@ export const refreshToken = async ({ token, refToken }, projectName) => {
             tokenID: newTokenID
         };
 
-    if (disabled) throw simplifyError('account_disabled', 'You cannot refresh token for this account because it has been disabled');
+    if (disabled)
+        throw simplifyError('account_disabled', 'You cannot refresh token for this account because it has been disabled');
 
     const [tokenx] = await Promise.all([
         signJWT({ ...tokenData }, projectName),

package/lib/products/auth/index.js

@@ -18,8 +18,7 @@ const {
     _facebookSignin,
     _twitterSignin,
     _githubSignin,
-    _signOut,
-    _invalidateToken
+    _signOut
 } = EngineRoutes;
 
 const authRoute = [
@@ -32,8 +31,7 @@ const authRoute = [
     // _twitterSignin,
     // _githubSignin,
     // _appleSignin,
-    _signOut,
-    _invalidateToken
+    _signOut
 ];
 
 export const authRoutes = ({
@@ -116,10 +114,6 @@ export const authRoutes = ({
                     ]);
                     res.status(200).send(makeResult({ status: 'success', result: r2 }));
                     break;
-                case _invalidateToken:
-                    const r3 = await invalidateToken(token, projectName);
-                    res.status(200).send(makeResult({ status: 'success', result: r3 }));
-                    break;
                 case _refreshAuthToken:
                     const r4 = await refreshToken({ token, refToken: r_token }, projectName);
                     res.status(200).send(makeResult({ status: 'success', result: r4 }));

package/lib/products/database/base.js

@@ -3,14 +3,14 @@ import { Scoped } from "../../helpers/variables.js";
 
 export const getDB = (projectName, name, url = DEFAULT_DB) => {
     if (!projectName) throw 'expected projectName in getDb()';
-    if (url === 'admin' || url === 'default') throw `invalid database url: "${url}"`;
+    if (url === 'admin' || url === 'default') throw `reserved keyword dbRef: "${url}"`;
 
     const dbUrl = url === ADMIN_DB_URL ? 'admin' : url === DEFAULT_DB ? 'default' : url,
         { defaultName: dbName, instance } = Scoped.InstancesData[projectName].mongoInstances[dbUrl] || {};
 
     if (name === ADMIN_DB_NAME) name = dbName;
-    if (!instance) throw `no MongoClient was found for database with url "${dbUrl}"`;
-    if (!name && !dbName) throw `no dbName found for database with url "${dbUrl}"`;
+    if (!instance) throw `no MongoClient was found for database with dbRef "${dbUrl}"`;
+    if (!name && !dbName) throw `no dbName found for database with dbRef "${dbUrl}"`;
 
     return instance.db(name || dbName);
 };

package/lib/products/database/index.js

@@ -249,8 +249,8 @@ export const emitDatabase = (path, callback, projectName, dbName, dbUrl, options
 
     const col = getDB(projectName, dbName, dbUrl).collection(path),
         stream = col.watch(pipeline, {
-            fullDocument: includeAfterData ? 'required' : undefined,
-            fullDocumentBeforeChange: includeBeforeData ? 'required' : undefined
+            fullDocument: includeAfterData ? 'whenAvailable' : undefined,
+            fullDocumentBeforeChange: includeBeforeData ? 'whenAvailable' : undefined
         });
 
     stream.on('change', l => {
@@ -325,6 +325,8 @@ const validateDbBody = (body, route) => {
                         if (!b.scope) throw simplifyError('required_field', `scope is required field at index ${i}`);
                     });
                 } else throw simplifyError('invalid_field_type', `"value" must be an array`);
+            } else if (k === 'stepping') {
+                if (typeof v !== 'boolean') throw simplifyError('invalid_value', `Invalid value supplied to stepping, expected a boolean but got ${v}`);
             } else throw simplifyError('invalid_field', `Unknown field "${k}"`);
         });
     } else if (route === '_readDocument' || route === '_listenDocument') {

package/lib/products/storage/index.js

@@ -4,9 +4,8 @@ import { Scoped } from "../../helpers/variables";
 import { validateJWT } from "../auth/tokenizer";
 import fs from 'fs';
 import { EngineRoutes, STORAGE_PATH, STORAGE_ROUTE } from "../../helpers/values";
-import { mkdirp } from 'mkdirp';
 import { StorageListener } from "../../helpers/listeners";
-import { unlink } from "fs/promises";
+import { mkdir, unlink } from "fs/promises";
 
 const { _uploadFile, _deleteFile, _deleteFolder } = EngineRoutes;
 
@@ -56,7 +55,9 @@ export const storageRoutes = ({ projectName, externalAddress, logger }) => [
                             destErr = validateDestination(destination);
 
                         if (destErr) throw simplifyError('invalid_destination', destErr);
-                        await mkdirp(tipDir);
+                        try {
+                            await mkdir(tipDir, { recursive: true, force: true });
+                        } catch (error) { }
                         let buf;
 
                         const sendEvent = () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mosquito-transport",
-  "version": "1.4.3",
+  "version": "1.4.6",
   "description": "MosquitoTransport is a powerful tool that helps persist and synchronize data between your MongoDB database and frontend applications",
   "main": "lib/index.js",
   "type": "module",
@@ -8,12 +8,7 @@
     "lib": "lib"
   },
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1",
-    "mongo-stop": "brew services stop mongodb-community",
-    "mongo-run": "brew services run mongodb-community",
-    "mongo-list": "brew services list",
-    "build": "rm -rf distx && babel lib --out-dir distx --copy-files",
-    "start": "nodemon --exec babel-node --experimental-modules --es-module-specifier-resolution=node lib/index.js"
+    "test": "echo \"Error: no test specified\" && exit 1"
   },
   "repository": {
     "type": "git",
@@ -37,7 +32,6 @@
   },
   "homepage": "https://github.com/deflexable/mosquito-transport#readme",
   "dependencies": {
-    "@types/express": "^4.17.20",
     "compression": "^1.7.4",
     "cors": "^2.8.5",
     "express": "^4.18.2",
@@ -45,8 +39,6 @@
     "json-buffer": "^3.0.1",
     "jsonwebtoken": "^9.0.0",
     "lodash": "^4.17.21",
-    "mkdirp": "^3.0.1",
-    "mongodb": "^5.3.0",
     "node-fetch": "^3.3.1",
     "set-large-timeout": "^1.0.1",
     "socket.io": "^4.6.1",
@@ -54,14 +46,8 @@
     "tweetnacl": "^1.0.3"
   },
   "devDependencies": {
-    "@babel/cli": "^7.21.5",
-    "@babel/core": "^7.21.5",
-    "@babel/node": "^7.20.7",
-    "@babel/preset-env": "^7.21.5",
-    "@babel/runtime": "^7.21.5",
+    "@types/express": "^4.17.20",
+    "@types/mongodb": "^4.0.7",
     "eslint": "^8.23.1"
-  },
-  "engines": {
-    "node": ">=14"
   }
-}
+}

package/rollup.config.js

@@ -1,34 +0,0 @@
-import babel from '@rollup/plugin-babel';
-import resolve from '@rollup/plugin-node-resolve';
-import { terser } from 'rollup-plugin-terser';
-
-export default {
-    input: './lib/index.js',
-    plugins: [
-        resolve(),
-        babel({
-            babelHelpers: 'bundled',
-            presets: [
-                ['@babel/preset-env', { targets: { node: 'current' }, modules: false }],
-            ],
-        }),
-        // terser(),
-    ],
-    output: [
-        {
-            dir: 'dist/esm',
-            format: 'es',
-            assetFileNames: '[name].[ext]'
-        },
-        {
-            dir: 'dist/cjs',
-            format: 'cjs',
-            assetFileNames: '[name].[ext]'
-        },
-        // {
-        //   file: 'dist/esm/index.min.js',
-        //   format: 'es',
-        // },
-    ],
-    external: ['mongodb', 'express', 'url', 'path', 'compression', 'socket.io','json-buffer', ''], // Add other external dependencies
-};