DEV Community: Ahmet ALMAZ

Maestral Review: Your Solution to Ignoring node_modules in Dropbox

Ahmet ALMAZ — Thu, 03 Aug 2023 08:13:24 +0000

Facing challenges when backing up projects to Dropbox is a common issue for Node.js developers, mainly because of the large and frequently updated node_modules folder. Nevertheless, the good news is that Maestral offers an innovative solution through its .mignore feature, allowing developers to seamlessly address this problem without the need to switch to a different cloud storage provider.

Info: ICYMI, I recently wrote two articles about how to exclude node_modules from syncing during backup. The first one uses rsync and the second one uses Filen

Maestral's .mignore feature functions similarly to the .gitignore in version control systems, empowering developers to exclude the bulky node_modules directory from syncing. This exclusion leads to faster backups and optimizes Dropbox storage usage.

In this review, we will delve into the essential aspects of Maestral and explore how it enhances the management of Dropbox files for Node.js developers, offering them more effective and efficient solutions.

Powerful Command Line Interface:

Maestral's command line interface (CLI) is a robust tool that puts users in control of their Dropbox files directly from the terminal.

This command line functionality provides a seamless and efficient way to manage Dropbox files without the need for a graphical user interface.

Here are 3 things you can do with Maestral's CLI:

Multiple Dropbox Accounts:

Maestral's CLI supports the configuration of an unlimited number of Dropbox accounts. Users can conveniently manage multiple Dropbox accounts by simply passing a new configuration name when linking a new account.

This feature is particularly valuable for individuals who need to separate personal and professional Dropbox accounts or manage multiple client accounts.

Unlimited Number of Devices:

Maestral offers the flexibility of connecting an unlimited number of devices to your Dropbox account without being restricted by the three-device limit imposed on Basic Dropbox accounts. Since Maestral is not an official Dropbox app, it does not count toward the device limit.

Effortless `.mignore` Integration:

Maestral's .mignore feature allows Node.js developers to effortlessly exclude the node_modules folder from Dropbox synchronization.

By creating an .mignore file in the root directory of your Dropbox account and specifying patterns, you can easily prevent the node_modules directory from being uploaded. This simple solution ensures that only essential project files are synced, saving you time and storage space while maintaining the integrity of your project.

To use Maestral to ignore the node_modules folder, you can follow these steps:

Install Maestral
Create an .mignore file in the root directory of your Dropbox account.
Add the following line to the .mignore file:

node_modules

Save the .mignore file.

Once you have followed these steps, Maestral will ignore the node_modules folder in Dropbox. This will save you time and storage space, and it will also improve the performance of your syncs.

Conclusion:

In conclusion, Maestral combines the power of its command line interface with various essential features.

These features provide a comprehensive and efficient Dropbox management solution, making Maestral an excellent choice for users looking to enhance their Dropbox experience.

Revolutionize Your Cloud Storage: Exclude node_modules with Filen

Ahmet ALMAZ — Wed, 12 Jul 2023 15:52:04 +0000

If you're a web developer who uses npm packages and backs up projects to Dropbox, chances are you've searched for a way to exclude the node_modules directory from syncing.

In the past, I relied on a custom bash script that used rsync to copy folders to a Dropbox folder while excluding certain files, folders, and everything listed in a .gitignore file. Although this solution worked well, it meant maintaining two copies of the backup.

Info: Make sure to check out my tutorial on How to Use rsync to Sync a Node Project to Dropbox and Ignore the node modules Folder

But now, with the introduction of Filen, things have changed. Filen is an alternative to Dropbox that offers advanced syncing options, including the ability to exclude the node_modules folder from syncing. No more worries about duplicating unnecessary files!

Well, with the introduction of Filen, I don't have to worry about this anymore. Filen is a Dropbox alternative that allows you to exclude the node_modules folder from syncing and so much more.

Introducing Filen: A Dropbox Alternative with Advanced Syncing Options

Filen is a zero knowledge end-to-end encrypted cloud storage that has all the features that you love and are used to from Dropbox, as well as an easy-to-use interface, encryption for all your data in a German high-security data center, the ability to share files and pictures using a private link or with other Filen users, syncing your data across multiple devices, ability to backup your camera folder from your phone automatically and selective sync option as well.

All of this is cool but one node_modules folder can ruin all of this for a web developer.

For those of you who don't know, a node_modules folder contains all the necessary files to run a Node.js project. Like this website that uses Next.js. The problem with it is that it can be large and time-consuming to sync due to its size and frequent updates.

For example, the node_modules folder for this website is '632.9 MB' and it contains '48,363' files. That takes forever to sync and any update, removal, or installation of a new module means syncing again and again.

With Filen, you don't have to worry about any of this. See, Filen has a neat feature that allows you to select files and folders to be ignored while syncing. Like a .gitignore file. They call it actually .filenignore file but in reality, it's not a file, it's a section in the app where you list the files and folders and it will do the rest.

Imagine having a Projects folder housing all your web development projects. By instructing Filen to sync the folder and selecting your preferred sync option (e.g., two-way, local to cloud, cloud to local, local backup, or cloud backup), you can then utilize the .filenignore option to exclude the node_modules folder from syncing.

Let Filen handle the synchronization while you focus on your development tasks, saving you time and ensuring a seamless experience.

You can sign up to Filen for free and we both get 10 GB of storage space. If you need more, you can upgrade to a paid plan. The paid plans start at 11.99€ annually for 100 GB of storage space or, you can pay 29.99€ for a lifetime plan with 100 GB of storage space. You can check out the pricing page for more options.

Conclusion

Say goodbye to the hassle of dealing with large node_modules folders during syncing.

Let Filen revolutionize your cloud storage experience by providing a simple yet powerful solution for excluding these folders effortlessly.

Use rsync to Sync a Node Project to Dropbox and Ignore the node modules Folder

Ahmet ALMAZ — Tue, 13 Jun 2023 18:00:00 +0000

This article Use rsync to Sync a Node Project to Dropbox and Ignore the node modules Folder was originally posted on News47ell.com. For more articles like this, click here.

When working on Node.js projects, it's common to have a large number of dependencies installed in the node_modules folder. This folder can be quite large and can slow down the syncing process when backing up or transferring your project to Dropbox.

To overcome this issue, you can use rsync, a powerful command-line tool for synchronizing files and directories, along with a bash script that excludes the node_modules folder and also filter out anything in a .gitignore file that you specify. In this article, I'll guide you through the process of setting up and using this bash script to sync your Node.js project while ignoring the node_modules folder.

Step 1: Create the Bash Script

To get started, open your favorite text editor and create a new file. You can name it something like sync-node-projects.sh. Paste the following code into the file:

#!/usr/bin/env bash

set -e # Exit on error

src_dir="$HOME/Projects/"
dest_dir="$HOME/Dropbox/Projects-Backup/"

# run rsync
rsync -a --delete \
  --filter=':- .gitignore' \
  --exclude='node_modules' \
  --exclude='.git' \
  --exclude='.DS_Store' \
  --chmod='F-w' \
  "$src_dir" "$dest_dir"

Let's go through the script and understand what each part does:

The first line (#!/usr/bin/env bash) specifies the interpreter for the script as bash.
The set -e command ensures that the script exits immediately if any command within it returns a non-zero status, indicating an error.
The src_dir variable defines the source directory path, where your Node.js project is located. Update it with the appropriate path for your system.
The dest_dir variable defines the destination directory path, where you want to backup or transfer your project. Modify it to suit your needs.
The rsync command is responsible for synchronizing the files and directories. Let's examine its options:
- The -a flag stands for "archive mode" and is a convenient way to sync files while preserving their permissions, ownership, and other attributes.
- The --delete option ensures that any files or directories that exist in the destination but not in the source are deleted during the sync. This helps keep both locations identical.
- The --filter=':- .gitignore' flag excludes files and directories specified in the .gitignore file from being synced. This ensures that files ignored by Git are also ignored by rsync.
- The --exclude='node_modules' option tells rsync to skip syncing the node_modules folder, which can be large and unnecessary for backup or transfer purposes.
- The --exclude='.git' flag excludes the .git folder, as it is not required for syncing and can be quite large.
- The --exclude='.DS_Store' option excludes the .DS_Store file, which is specific to macOS and contains metadata that is not relevant for syncing.
- The --chmod='F-w' flag removes write permissions from all files in the destination directory, ensuring they remain read-only. This prevents accidental modifications in the backup location.

Step 2: Save and Make the Script Executable

After pasting the script into your text editor, save the file and navigate to the location where you saved it using the terminal. To make the script executable, run the following command:

chmod +x sync-node-project.sh

This command grants execute permissions to the script.

Step 3: Run the Script

To sync your Node.js project, open a terminal and navigate to the location of the script. Execute the script by running the following command:

./sync-node-project.sh

The script will start syncing your Node.js project from the source directory (src_dir) to the destination directory (dest_dir), excluding the node_modules folder.

Conclusion

Congratulations! You have successfully set up a bash script that uses rsync to sync your Node.js project while ignoring the node_modules folder. By excluding this folder from the syncing process, you can save time and space, especially when working with large projects. Remember to run the script whenever you want to sync your project, and all your changes will be transferred while keeping the unnecessary node_modules folder out of the equation.

Real-time page views with Next.js, Turso and Drizzle ORM

Ahmet ALMAZ — Fri, 02 Jun 2023 20:03:45 +0000

This article Real-time page views with Next.js, Turso and Drizzle ORM was originally posted on News47ell.com. For more articles like this, click here.

If you're searching for a simple and effective method to incorporate real-time page views into your Next.js website, you've come across the perfect tutorial on this topic. In this article, I will guide you through the process of integrating real-time page views into your Next.js website using Turso and Drizzle ORM.

Turso: A Game-Changing SQLite Edge Database

Let me introduce you to Turso, the groundbreaking SQLite edge database that will revolutionize your website. Turso is built on the robust libSQL framework and offers an astonishing free plan that lasts indefinitely. With this plan, you'll enjoy a generous 8 GB of total storage and the ability to create up to 3 databases across 3 different locations. Prepare to have your expectations completely exceeded!

Drizzle ORM: The Cutting-Edge Object-Relational Mapping Library

Drizzle ORM is an advanced object-relational mapping library designed specifically for Node.js and TypeScript applications. This powerhouse provides comprehensive support for multiple databases, migrations, and query building. It's like having a turbocharged engine powering your website!

Setup Turso database

Install the Turso CLI (For more options Click here):

brew install chiselstrike/tap/turso

turso auth signup

Create a new database

turso db create [db-name]

Get the URL of your database (Starts with libsql://):

turso db show [db-name]

Access your database shell:

turso db shell [db-name]

Create a new table for views:

CREATE TABLE IF NOT EXISTS views (
    slug TEXT PRIMARY KEY,
    title TEXT,
    count INTEGER
);

Create an auth token

turso db tokens create [db-name] -e none

Now inside .env file, add the following:

DATABASE_URL=libsql://[db-url]
DATABASE_AUTH_TOKEN=[auth-token]

Connect Next.js to Turso

In order to connect our site to the database, we need to use Drizzle ORM. All we have to do is install couple of packages and set them up.

Install Drizzle ORM and libSQL client:

npm i drizzle-orm @libsql/client

Create a file lib/turso.ts to initialize your Turso client

import { createClient } from '@libsql/client'
import { drizzle } from 'drizzle-orm/libsql'
import { integer, sqliteTable, text } from 'drizzle-orm/sqlite-core'

const connection = createClient({
    url: process.env.DATABASE_URL || '',
    authToken: process.env.DATABASE_AUTH_TOKEN,
})

export const db = drizzle(connection)

export const viewsTable = sqliteTable('views', {
    slug: text('slug').primaryKey(),
    count: integer('count').notNull().default(0),
})

Now we create app/api/views/[slug]/route.ts and use it to increment and fetch page views

import { eq } from 'drizzle-orm'
import { type NextRequest, NextResponse } from 'next/server'
import { z } from 'zod'

import { db, viewsTable } from '@/lib/turso'

interface Options {
    params: {
        slug: string
    }
}

export const GET = async (request: NextRequest, { params }: Options) => {
    const slug = z.string().parse(params.slug)

    const data = await db.select().from(viewsTable).where(eq(viewsTable.slug, slug)).all()

    const count = !data.length ? 0 : Number(data[0].count)

    return NextResponse.json({ count })
}

export const POST = async (request: NextRequest, { params }: Options) => {
    const slug = params.slug

    const data = await db.select().from(viewsTable).where(eq(viewsTable.slug, slug)).all()

    const count = !data.length ? 0 : Number(data[0].count)

    await db
    .insert(viewsTable)
    .values({
      slug,
      count: 1,
    })
    .onConflictDoUpdate({
      target: viewsTable.slug,
      set: {
        count: count + 1,
      },
    })
    .returning()
    .get()

    return NextResponse.json({ count: count + 1 })
}

Finally, we create ViewCounter.tsx component to display the page views which we can use in our blog posts

'use client'

import { useEffect } from 'react'
import useSWR from 'swr'

import fetcher from '@/lib/fetcher'
import { PostView } from '@/lib/types'

export default function ViewsCounter({ slug, trackView }: { slug: string; trackView: boolean }) {
    const { data } = useSWR<PostView>(`/api/views/${slug}`, fetcher)
    const views = new Number(data?.count || 0)

    useEffect(() => {
        const registerView = () => {
            fetch(`/api/views/${slug}`, {
                method: 'POST',
            })
        }

        if (trackView) {
            registerView()
        }
    }, [slug])

    return (
        <p className="font-mono text-sm tracking-tighter">
            {data ? `${views.toLocaleString()} views` : '--- views'}
        </p>
    )
}

Conclusion

Now we have a working page views counter that is connected to our Turso database. You can use this method to add page views to any website that is built with Next.js.

DEV Community: Ahmet ALMAZ

Maestral Review: Your Solution to Ignoring node_modules in Dropbox

Powerful Command Line Interface:

Multiple Dropbox Accounts:

Unlimited Number of Devices:

Effortless .mignore Integration:

Conclusion:

Revolutionize Your Cloud Storage: Exclude node_modules with Filen

Introducing Filen: A Dropbox Alternative with Advanced Syncing Options

Conclusion

Use rsync to Sync a Node Project to Dropbox and Ignore the node modules Folder

Step 1: Create the Bash Script

Step 2: Save and Make the Script Executable

Step 3: Run the Script

Conclusion

Real-time page views with Next.js, Turso and Drizzle ORM

Turso: A Game-Changing SQLite Edge Database

Drizzle ORM: The Cutting-Edge Object-Relational Mapping Library

Setup Turso database

Connect Next.js to Turso

Conclusion

Effortless `.mignore` Integration: