DEV Community: Monawwar Abdullah

Why I built Drivebase. An open-source unified file manager.

Monawwar Abdullah — Wed, 04 Mar 2026 10:30:44 +0000

First of all, a huge thank you to everyone who has starred the repo. 😊

It started back in 2025 when I wanted to upload files to Telegram. I had many files in Saved Messages, but it was becoming difficult to manage them. I didn’t have a structured way to organize my files. I wanted a place where I could create folders and upload files, while the content would still be saved in Telegram’s Saved Messages. So I built Xile, a file manager specifically for Telegram.

App UI
   ↓
Backend
   ↓
Telegram API
   ↓
Saved Messages storage

Website: https://drivebase.io
Source code: https://github.com/drivebase/drivebase

What Drivebase Can Do Today

Fast forward today, its now been renamed to Drivebase, and supports not only Telegram but major other storage provider, and slowly adding more in the future as the app grows.

Drivebase evolved from a Telegram file hack into a unified storage layer. Instead of juggling multiple storage apps, Drivebase lets you connect them all in one place and manage them through a single interface.

interface StorageProvider {
  upload()
  download()
  list()
  delete()
}

Installation

Run the following command to get started, it creates a folder and downloads the latest Docker compose file and spin up all the services required.

curl -fsSL https://drivebase.io/install | bash

Multiple Storage Providers

Today, Drivebase supports several major storage providers.

You can connect:

Google Drive
S3 compatible storage (AWS S3, Cloudflare R2, MinIO, etc.)
Dropbox
WebDAV servers
Nextcloud
Telegram

A Unified File Manager

Instead of switching between multiple apps, Drivebase gives you a single interface to manage everything.

From the UI you can:

Browse files
Create folders
Upload and download files
Move files between folders
Manage multiple drives

The experience is intentionally designed to feel like a normal file manager, even though the data may live across completely different providers.

Features

Beyond simply connecting storage providers, Drivebase adds several layers of functionality that most storage platforms don’t provide out of the box.

1. End-to-End Encrypted Vault

Drivebase includes an optional E2EE Vault for storing sensitive files.

Files placed inside the vault are encrypted on the client before being uploaded to the storage provider. This means:

the storage provider cannot read the file contents
Drivebase servers cannot read the file contents
only the user with the vault key can decrypt them

This allows you to store private data even on third-party storage providers while keeping full control over encryption.

2. Rule-Based Smart Uploads

Drivebase can automatically decide where files should be stored based on configurable rules.

For example:

Upload videos larger than 500MB → S3 storage = Documents → Google Drive
Backups → self-hosted WebDAV
Temporary files → Telegram storage

Instead of manually selecting a destination each time, Drivebase routes uploads automatically using these rules.

This turns Drivebase into a storage router, not just a file manager.

3. Smart Search Across Providers

Searching files across multiple storage providers is usually painful.

Drivebase solves this by building a unified metadata index, allowing you to search files across all connected providers at once.

You can search by:

file name
file content
image text (OCR)
folder path

Instead of checking five different apps, you can locate any file from a single search bar.

4. Cloud-to-Cloud Transfers

Drivebase supports direct transfers between storage providers.

For example:

Google Drive → S3
Dropbox → Nextcloud
Telegram → S3

This removes the need to:

download files locally
re-upload them somewhere else

Drivebase handles the transfer between providers automatically.
This is particularly useful for migrations and backups.

5. Granular API Keys

Most storage services force you to give third-party tools full account access.

Drivebase introduces granular API keys so you can restrict exactly what an integration is allowed to do.

API keys can be limited by:
specific storage providers
specific folders within a provider
allowed operations (upload, read, delete, etc.)

This allows safer integrations without exposing your entire storage account.

Built for Self-Hosting

Drivebase is also designed to be easy to run yourself.

You can deploy it with Docker and connect it to the storage providers you already use.

This makes it useful for:

personal file management
home labs
teams managing multiple storage systems
developers building storage workflows

Restflow: CLI tool for API testing

Monawwar Abdullah — Mon, 01 Sep 2025 14:01:08 +0000

What is Restflow?

Restflow is an innovative API testing and workflow automation tool that uses .flow files to define test scenarios in plain text. With Restflow, you can create comprehensive API test suites that are as easy to read as they are to write.

Key Features at a Glance

🌊 Simple DSL: Write API tests in human-readable .flow files
🔧 Variable Substitution: Dynamic values with {{variable}} syntax
🌍 Environment Support: Multi-environment testing with .env files
✅ Powerful Assertions: JSONPath and regex-based response validation
📊 Multiple Output Formats: Console, JSON, and summary reports
🔗 Step Dependencies: Capture values and chain requests
⚡ Fast Execution: Concurrent processing with timeout support
🎯 Built-in Variables: UUID, timestamp, random values out of the box

Why Restflow Stands Out

1. Human-Readable Syntax

Traditional API testing tools often require you to write complex JSON configurations or learn proprietary syntax. Restflow's DSL reads like documentation:

### Get User Profile
GET https://api.example.com/users/123
Authorization: Bearer {{token}}

> assert status == 200
> assert body.name == "John Doe"
> assert body.email contains "@example.com"

Compare this to a typical JSON-based test configuration, and the difference is immediately clear – Restflow flows are self-documenting.

2. Zero Configuration Setup

Getting started with Restflow is as simple as:

# Create a new project with templates
pnpm create restflow

# Or add to an existing project
pnpm add -D @restflow/cli

# Or install globally
npm install -g @restflow/cli

No complex configuration files, no framework setup – just create a .flow file and you're ready to test.

3. Built-in Intelligence

Restflow comes with intelligent built-in variables that generate fresh values on each run:

{{uuid}} - Generates unique UUIDs for test data
{{timestamp}} - Current Unix timestamp
{{randomString}} - Random alphanumeric strings
{{randomNumber}} - Random numbers for test scenarios

Real-World Use Cases

1. E-commerce Platform Testing

Let's say you're testing an e-commerce API. Here's how you might test the complete user journey:

### Register New Customer
POST https://api.shop.com/auth/register
Content-Type: application/json

{
  "email": "customer-{{uuid}}@test.com",
  "password": "SecurePass123",
  "firstName": "Test",
  "lastName": "Customer"
}

> assert status == 201
> assert body.success == true
> capture customerId = body.customer.id
> capture authToken = body.token

### Login Customer
POST https://api.shop.com/auth/login
Content-Type: application/json

{
  "email": "customer-{{uuid}}@test.com",
  "password": "SecurePass123"
}

> assert status == 200
> assert body.token != null
> capture loginToken = body.token

### Browse Products
GET https://api.shop.com/products?category=electronics
Authorization: Bearer {{loginToken}}

> assert status == 200
> assert body.products.length > 0
> capture firstProductId = body.products[0].id
> capture productPrice = body.products[0].price

### Add to Cart
POST https://api.shop.com/cart/add
Authorization: Bearer {{loginToken}}
Content-Type: application/json

{
  "productId": "{{firstProductId}}",
  "quantity": 2
}

> assert status == 200
> assert body.cart.items.length == 1
> assert body.cart.total == {{productPrice}} * 2

### Checkout Process
POST https://api.shop.com/orders/create
Authorization: Bearer {{loginToken}}
Content-Type: application/json

{
  "paymentMethod": "credit_card",
  "shippingAddress": {
    "street": "123 Test St",
    "city": "Test City",
    "zip": "12345"
  }
}

> assert status == 201
> assert body.order.status == "pending"
> assert body.order.customerId == "{{customerId}}"
> capture orderId = body.order.id

2. Authentication & Authorization Testing

Testing complex auth flows becomes straightforward:

### Admin Login
POST https://api.company.com/auth/admin/login
Content-Type: application/json

{
  "username": "{{adminUser}}",
  "password": "{{adminPassword}}"
}

> assert status == 200
> assert body.user.role == "admin"
> assert body.permissions contains "user_management"
> capture adminToken = body.token

### Create Regular User
POST https://api.company.com/users
Authorization: Bearer {{adminToken}}
Content-Type: application/json

{
  "username": "testuser_{{timestamp}}",
  "email": "user{{randomNumber}}@test.com",
  "role": "user"
}

> assert status == 201
> capture newUserId = body.id

### Test Permission Boundaries
DELETE https://api.company.com/users/{{newUserId}}
Authorization: Bearer {{userToken}}

> assert status == 403
> assert body.error == "Insufficient permissions"

### Admin Can Delete User
DELETE https://api.company.com/users/{{newUserId}}
Authorization: Bearer {{adminToken}}

> assert status == 204

Advanced Features

Environment-Specific Testing

Restflow makes multi-environment testing seamless:

# Development environment
restflow run flows/ --env .env.dev

# Staging environment  
restflow run flows/ --env .env.staging

# Production health checks
restflow run health-checks/ --env .env.prod

Your .env.staging file might look like:

BASE_URL=https://staging-api.example.com
API_KEY=staging_key_12345
DATABASE_URL=postgres://staging-db:5432/app
TIMEOUT=30000

Multiple Output Formats

Restflow adapts to different needs:

# Human-readable console output (default)
restflow run flows/

# JSON for CI/CD integration
restflow run flows/ --format json > test-results.json

# Concise summary for monitoring
restflow run flows/ --format summary

Variable Hierarchy and Overrides

Restflow provides a sophisticated variable system with clear precedence:

Built-in variables (lowest priority): {{uuid}}, {{timestamp}}
Environment variables: From .env files
Captured variables: From previous response steps
CLI variables (highest priority): Passed via command line

This means you can override built-in variables when needed:

# Override for consistent testing
uuid=test-user-12345
timestamp=1640995200

Integration with CI/CD

Restflow is designed for seamless integration into modern development workflows:

GitHub Actions

name: API Tests
on: [push, pull_request]

jobs:
  api-tests:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - uses: actions/setup-node@v3
        with:
          node-version: '18'

      - name: Install Restflow
        run: npm install -g @restflow/cli

      - name: Run API Tests
        run: restflow run tests/api/ --env .env.ci --format json

      - name: Upload Results
        uses: actions/upload-artifact@v3
        with:
          name: api-test-results
          path: test-results.json

Docker Integration

FROM node:18-alpine
RUN npm install -g @restflow/cli
COPY flows/ /app/flows/
COPY .env.docker /app/.env
WORKDIR /app
CMD ["restflow", "run", "flows/", "--env", ".env", "--format", "json"]

Performance and Scalability

Restflow is built for performance:

Concurrent Execution: Multiple requests run in parallel
Configurable Timeouts: Fine-tune performance for your needs
Efficient Memory Usage: Minimal overhead for large test suites
Fast Startup: No heavy framework initialization

# Run with custom timeout and verbose output
restflow run large-test-suite/ --timeout 60000 --verbose

Best Practices and Patterns

1. Modular Flow Design

Organize flows by feature or service:

flows/
├── auth/
│   ├── 01-registration.flow
│   ├── 02-login.flow
│   └── 03-password-reset.flow
├── users/
│   ├── 01-profile-crud.flow
│   ├── 02-permissions.flow
│   └── 03-user-search.flow
└── orders/
    ├── 01-create-order.flow
    ├── 02-order-status.flow
    └── 03-order-cancellation.flow

2. Effective Variable Usage

Use descriptive variable names and leverage the hierarchy:

### Setup Test Data
POST {{BASE_URL}}/test-data/setup
Content-Type: application/json

{
  "scenario": "user_registration_flow",
  "timestamp": "{{timestamp}}"
}

> capture testDataId = body.id

### Use Test Data
GET {{BASE_URL}}/data/{{testDataId}}
X-Test-Run: {{uuid}}

> assert body.scenario == "user_registration_flow"

3. Comprehensive Error Testing

Don't just test the happy path:

### Test Rate Limiting
POST {{BASE_URL}}/api/endpoint
Content-Type: application/json

{"data": "test"}

> assert status == 200

### Trigger Rate Limit
POST {{BASE_URL}}/api/endpoint
POST {{BASE_URL}}/api/endpoint
POST {{BASE_URL}}/api/endpoint
POST {{BASE_URL}}/api/endpoint
POST {{BASE_URL}}/api/endpoint

> assert status == 429
> assert body.error contains "rate limit"
> assert headers["retry-after"] matches "\\d+"

The Future of API Testing

Restflow represents a paradigm shift in API testing philosophy. By prioritizing readability, simplicity, and developer experience, it enables teams to:

Write tests faster: No complex setup or learning curve
Maintain tests easier: Human-readable syntax that doubles as documentation
Collaborate better: Non-technical team members can understand and contribute
Scale confidently: Robust execution engine handles complex scenarios

Upcoming Features

The Restflow roadmap includes exciting developments:

GUI Test Builder: Visual flow creation for non-technical users
Real-time Monitoring: Continuous API health monitoring
Advanced Reporting: Detailed analytics and trend analysis
Plugin System: Extensible architecture for custom functionality
Cloud Integration: Hosted execution and collaboration features

Resources

GitHub Repository: https://github.com/mxvsh/restflow
Documentation: Comprehensive guides in the repository
Examples: Real-world flows in the examples/ directory
Community: Join discussions in GitHub Issues
NPM Package: @restflow/cli for global installation

Transform your API testing workflow with Restflow – where simplicity meets power, and testing becomes a joy rather than a chore.

Execute Async Server Function from Client Side

Monawwar Abdullah — Sun, 12 Sep 2021 05:22:53 +0000

Execute server's asynchronous functions from client-side

Often it happens while writing web application that you need to make HTTP requests to fetch, create, update or delete data from database.

With RealSync, you wouldn't have to remember all those HTTP endpoints, and perform actions as if you're executing server functions from client-side.

RealSync uses web socket to make contact with the server and execute asynchronous function and returns promise which you can await in the client side. Here is an example of a server code, you can connect it with Express or Koa, if you want.

const http = require('http')
const app = http.createServer()
const { RealSync } = require('../packages/server/lib')

const realsync = new RealSync(app, '*')

realsync.register('profile/setup', async (client) => {
    const firstName = await client.run('profile/firstname')
    const lastName = await client.run('profile/lastname')

    return { firstName, lastName }
})

app.listen(8080, () => {
    console.log('8080')
})

This will register a service “add” in realsync and accept two parameters, a and b.

And here is a client demonstration using React:

import { RealSync } from '@realsync/react'
const realsync = new RealSync('http://localhost:8080')

function App() {
    useEffect(() => {
        // this will register services

        realsync.register('profile/firstname', () => {
            return prompt('Enter first name')
        })

        realsync.register('profile/lastname', () => {
            return prompt('Enter last name')
        })
    }, [])

    const Start = async () => {
        const profile = await realsync.service('profile/setup')
        console.log('profile', profile)
    }

    return (
        <div>
            <button onClick={Start}>Start</button>
        </div>
    )
}

I would love to have feedback forum you guys. I’ve more to add in this library.

GitHub: https://GitHub.com/xencodes/realsync

Realtime connector for Strapi

Monawwar Abdullah — Wed, 08 Sep 2021 10:10:22 +0000

I've been using Strapi in many of my projects, and I love using it. So, to make it easier for Strapi developer to build awesome apps using React, I've made Floxum which can add an extra layer to Strapi, and that is Realtime.

Floxum uses Socket.IO in the background to communicate with Strapi server, and from the client side, a user can execute Strapi services. Here is an example:

floxum.services('todo', 'find', { _limit: 1 }).then((data) => {
   console.log(data)
})

This is an async function, which will execute find method on the Strapi server and returns the output using a Promise. This is just like you're execute a Strapi's server functions directly from React application.

This way, it's easier to build React apps connected with Strapi without making about HTTP requests, like we use axios or fetch.

Installation

The installation will also work for the projects which are already using Strapi.

Step 1

Install the following module inside your React project:

yarn add @floxum/react

Step 2

Install the following module inside your Strapi application:

yarn add @floxum/core

Step 3

Create a new file inside your React application to setup Floxum at src/providers (or anywhere you'd want) named floxum.js, and paste the following code.

import Floxum from '@floxum/react'

const floxum = Floxum('http://localhost:1337')

export default floxum

Change the host string to your Strapi host.

Step 4

Inside your Strapi applicaiton, go to config/functions/bootstrap.js, and import Floxum then call it inside the export module with strapi parameters:

"use strict";
const folxum = require("@floxum/core");

module.exports = async () => {
  folxum(strapi);
};

You're now good to go!

Step 5

Inside your Rect project (in any component) import Floxum and and test it by calling ping function, like this:

useEffect(() => {
  floxum.ping().then(() => {
    console.log('working')
  })
}, []);

CopyDock - Handy VSCode Extension

Monawwar Abdullah — Wed, 30 Jun 2021 00:00:00 +0000

CopyDock

I've been working on a project with my friend and while we were coding, we got at some point that I've to write my friend's code to my computer because that code was working or transfer the development environment values to my Workspace, but it's a long way to copy that text or code snippet to my PC; usually via a messaging platform like Telegram, so I decided to develop an extension for VSCode that could do that job easily. And in this post we'll see how we can use CopyDock.

Step 1 - Installation

Open your Visual Studio Code editor and go to extension tab and search for "CopyDock" or you can just visit the link below to install the extension.

Direct link to the extension: https://marketplace.visualstudio.com/items?itemName=xencodes.copydock

After the installing you will see your ID at the bottom menu of VSCode.

Here, my ID is oj

Step 2 - Transfer your Code

Now, it's time for you to do a selection of the code snippet or any other text and right-click on it, and then hit "Send Code", next you will be asked to enter User ID; you will have to put your friend ID in the input box and press enter to transfer the selected text into your friend's Workspace.

As you can see, I entered nR in the input box as User ID to transfer the selected text to my another Visual Studio Code instance (for the demonstration I used VSCode and VSCode Insiders).

And soon you hit Enter, your selected should get copied over to your friend's Workspace.