DEV Community: anthony amaro

I Got Tired of cd-ing Into Nested Folders, So I Built a File Finder in Rust

anthony amaro — Wed, 04 Feb 2026 03:13:09 +0000

I like keeping my projects organized. Maybe a little too organized.

My folder structure looks something like this:

~/projects/work/projects/client-name/frontend/app
~/projects/personal/rust/file-finder
~/projects/side-projects/2024/some-idea

For a while, my workflow to open a project was:

cd projects
cd work
cd client-name
cd frontend
cd app
nvim .

Six commands just to start working. Every. Single. Time.

I tried tools like fzf and ranger. They're great, but they didn't quite solve my problem. fzf finds files, but after selecting one, I'm still in my original directory. Ranger lets me browse around, but it's more of a file manager than a quick project launcher.

What I really wanted was simple: type the project name, press Enter, and be there. No extra steps.

I couldn't find anything that did exactly that. So I built it.

The idea

I was also looking for an excuse to learn Rust. Building something I'd actually use every day seemed like the right approach — not another tutorial project that sits in a folder forever.

The core concept was straightforward:

Cache my directory structure so searching is instant
Fuzzy search to find what I need
When I select a directory, actually cd into it in my shell

That last part is the trick. Most terminal tools run in a subprocess — they can't change your shell's working directory. I solved this with shell integration. You add one line to your .zshrc:

eval "$(ff init zsh)"

Now when I press Enter on a directory, my terminal is actually in that directory. I just type nvim . and I'm working.

The workflow became:

ff       # launch
# type "client-name"
# press Enter
nvim .   # already there

That's it. No more cd chain.

What it turned into

What started as a simple project launcher grew into a full terminal file explorer. Once I had the foundation, I kept adding things I found useful:

Fuzzy search — Local search in the current directory, or prefix with / for global search across your entire cached directory tree.

File previews — Syntax highlighting for code, image rendering (in supported terminals), PDF text extraction, hex view for binaries. It's useful to see what's in a file before opening it.

Vim-style navigation — h, j, k, l to move around. i to search. Muscle memory from Neovim transfers directly.

Dual-pane mode — Side-by-side file management for when you need to copy or move files between directories. Press p to cycle through view modes.

IDE integration — Open files directly in Neovim, VS Code, or Zed. No need to copy the path manually.

Real-time updates — File system watching means if something changes in the directory, you see it immediately.

Lessons from building it

A few things I learned along the way:

Caching matters. The first time you run ff, it builds a cache of your directory structure. After that, global search is instant. Without caching, searching a large directory tree would be painfully slow.

Rust's ecosystem is solid. Libraries like ratatui for terminal UI, syntect for syntax highlighting, and fuzzy-matcher made this possible without reinventing everything.

Build something you'll use. I use ff dozens of times a day. That motivation kept me going when I hit roadblocks.

Try it

If you're on macOS or Linux:

brew install anthonyamaro15/tap/ff
eval "$(ff init zsh)"  # add to your .zshrc

Then just run ff and start typing.

The repo is at github.com/anthonyamaro15/file-finder-rust. Feedback, issues, and PRs are welcome.

If you've ever been frustrated by cd-ing five times to reach a project, give it a shot.

How to implement reset password functionality with Node/PostgreSQL/Knex

anthony amaro — Wed, 17 Feb 2021 03:10:00 +0000

Have you ever wondered how to implement a reset password functionality on the server with NodeJS and PostgreSQL?

I found many articles and tutorials on how to do it with Node and MongoDB, here I'm going to tell you how I've done it with PostgreSQL.

First, we need to find an email service, I've tried Nodemailer at first and it works perfectly in my local environment, however, in production I was getting some security issues with my Gmail account. That's why I decided to go with SendGrid.

Create a SendGrid account, go to Email API, Integration Guide, choose Web API and just follow instructions to generate an API Key

Install dependencies

npm install --save @sendgrid/mail
npm install express bcryptjs jsonwebtoken knex

Now that you have created the API key, create a .env file to store your key.

Let's see how our user table looks
I'm using the Knex library to interact with the database

table.increments();
table.string("email", 128).unique().notNullable();
table.string("password", 128).notNullable();
table.string("resetLink", 255);

As you see we define "resetLink" to be optional.

Now let's create the routes

const express = require('express');
const bcrypt = require('bcryptjs');
const jwt = require('jsonwebtoken');
const sgMail = require('@sendgrid/mail');

const route = express.Router();
// bring env variables into file
const sendGridKey = process.env.SENDGRID_KEY;
const resetSecret = process.env.RESET_SECRET;

route.patch('/forgot-password', async (req, res) => {
  const { email } = req.body;

  try {
    // look for email in database
    const [user] = await filterBy({ email });
    // if there is no user send back an error
    if(!user) {
      res.status(404).json({ error: "Invalid email" });
    } else {
      // otherwise we need to create a temporary token that expires in 10 mins
      const resetLink = jwt.sign({ user: user.email }, 
      resetSecret, { expiresIn: '10m' });
      // update resetLink property to be the temporary token and then send email
      await update(user.id, { resetLink });
      // we'll define this function below
      sendEmail(user, resetLink);
      res.status(200).json({ message: "Check your email"} );
    }
  } catch(error) {
    res.status(500).json({ message: error.message });
  }
}

Let's define the new PATCH route to update the new password


route.patch('/reset-password/:token', async (req, res) => {
  // Get the token from params
  const resetLink = req.params.token;
  const newPassword = req.body;

  // if there is a token we need to decoded and check for no errors
  if(resetLink) {
    jwt.verify(resetLink, resetPassword, (error, decodedToken) => {
         if(error) {
           res.status().json({ message: 'Incorrect token or expired' })
         }
    })
  }

  try {
    // find user by the temporary token we stored earlier
    const [user] = await filterBy({ resetLink });

    // if there is no user, send back an error
    if(!user) {
      res.status(400).json({ message: 'We could not find a match for this link' });
    }

    // otherwise we need to hash the new password  before saving it in the database
    const hashPassword = bcrypt.hashSync(newPassword.password, 8);
    newPassword.password = hashPassword;

    // update user credentials and remove the temporary link from database before saving
    const updatedCredentials = {
      password: newPassword.password,
      resetLink: null
    }

    await update(user.id, updatedCredentials);
    res.status(200).json({ message: 'Password updated' });
  } catch (error) {
    res.status(500).json({ message: error.message });
  }
})

Let's also define the functions we are using to interact with the database in this case is
findBy() and update()

// I'm using knex to interact with the database here
// but all is doing is looking into 'users' table and filtering the data by the filter parameter
function filterBy(filter) {
  return db('users').where(filter);
}

// same here, looking into 'users' table by 'id' and then updating the values
function update(id, changes) {
  return db('users').where({ id }).update(changes);
}

Let's define sendEmail function

function sendEmail(user, token) {
  sgMail.setApiKey(sendGridKey);
  const msg = {
    to: user.email,
    from: "", // your email
    subject: "Reset password requested",
    html: `
     <a href="${clientURL}/reset-password/${token}">${token}</a>
   `
   // I'm only going to use an (a tag) to make this easier to
   // understand but feel free to add any email templates 
   // in the `html` property
  };

  sgMail.send(msg)
    .then(() => {
      console.log("Email sent");
  }).catch((error) => {
      console.error(error);
  })
}

Now that we've created the routes I'm going to use Postman to test it, we need to make a PATCH request

You should get a 200 status if everything is okay, check your email and copy the token from the email

On Postman paste the token url/auth/reset-password/:token
see example below

You should get a 200 status code with a Password update message

Here is a link to one of my repos with full example code repo

I hope you find this helpful! If you have any questions let me know in the comments.
I'm planning to add the same functionality but using Redis to store the temporary token instead of the database.

My experience in my labs project in Lamda School

anthony amaro — Fri, 25 Sep 2020 02:54:32 +0000

This is the first part of my labs project.

what's it like to work as a team?

anthony amaro ・ Aug 28 '20

Today we are going to be going over what the second part of my labs project was and is a small description of what we've built on the second portion.

Once we filled the database with the bridges and villages data we noticed that it would take between 3.5 to 4 seconds to get the data, We needed a way to somehow improve the performance.
One of the solutions we came up with was to cache the data, and for that, we decided to go with Redis.

After we cached the data the performance increased by about 60% now taking between 100 to 200 milliseconds. Much faster right? To implement Redis it was actually quite easy. Here are some screenshots on how to implement it.

On line 79 we get the variable with the name bridges and a callback function with 2 parameters, after that, we check if the error is true it means we don't have anything store with the name of bridges.
Then on line 84, we check if data is true, it means we have it stored and we send that data.

If none of those conditions are met then we get to line 89 where we get the data from the database, send the data and then save it in Redis.

It was an amazing experience to have worked with an awesome team, I'm grateful to have the opportunity to work with them and I feel that we definitely did a great job. If you are wondering how the project looks like here it is.
website here

what's it like to work as a team?

anthony amaro — Fri, 28 Aug 2020 01:45:48 +0000

The project that I'm currently working on is about a company that builds bridges to help people in Africa, and the problem that my team and I are trying to solve is for users and admins to have a better visualization to where bridges are built and the communities that those bridges help.

The first thing we did was decided what the functionality of the project was and then break the tasks into smaller features. On the Back-end we started with the tasks that the front-end developers on my team needed and sending fake data just so the could have something to work with.
Here is a screenshot on what I've worked on

What we accomplished on this pull request was manipulated a large amounts of data about bridges and villages and joined them together to display where communities were served by building the bridges.

Facing challenges

One challenge that we faced was that when we received the data, that data did not match with our data schema, what we decided to do was iterated over all the data and lowercase all the keys of the objects and removed all the spaces from them. after that we just overwrite the old keys to match with the ones from our schemas.

Here is an example of the code we wrote.

Currently in progress

A challenge we are facing is when sending the data to the front-end we need to somehow paginate the data because if we send the data as it is, it takes approximately 7 seconds for the front-end to receive the data.

shipped features

Created tables for the database.
Created migrations and seeds for the database.
Created CRUD operations for villages and bridges Routes.
Added documentation for API Routes.
Manipulated data to display bridge information with the communities it served.

One future feature I think we can implement if we get the coordinates of the village so we can display villages in the front-end on the map as well.
And there are a few things I think it may cause problems with the performance, that might be a fun challenge to work on.

Some of the feedback I received from my teammates was that I should ask for help sooner so I don't waste valuable time and what I'm doing to improve is reaching out for help sooner.

This project has been an amazing experience for me so far, I learned a lot of new things, and the experience to work as a team was incredible.