DEV Community: Fredy Sandoval

Terminal Tip 🤩 fcopy, fcut, fpaste

Fredy Sandoval — Sun, 15 Mar 2026 02:47:00 +0000

If you are like me and love the terminal, start using fcopy, fcut, fpaste

how does it work, instead of copying through a file explorer, just do:

$ fcopy some/file/
$ fcopy other/file/image.png

then open other terminal and do:

$ fpaste

fcopy() {
  if [ "$#" -eq 0 ]; then
    echo "fcopy: nothing to copy"
    return 1
  fi

  tmp="$(mktemp)"
  printf 'copy\n' > "$tmp"

  for item in "$@"; do
    if [ -e "$item" ]; then
      abs="$(realpath "$item")"
      printf '%s\n' "$abs" >> "$tmp"
      echo "copied to clipboard: $abs"
    else
      echo "fcopy: not found: $item" >&2
    fi
  done

  mv "$tmp" ~/.fileclip
}

fcut() {
  if [ "$#" -eq 0 ]; then
    echo "fcut: nothing to cut"
    return 1
  fi

  tmp="$(mktemp)"
  printf 'move\n' > "$tmp"

  for item in "$@"; do
    if [ -e "$item" ]; then
      abs="$(realpath "$item")"
      printf '%s\n' "$abs" >> "$tmp"
      echo "cut to clipboard: $abs"
    else
      echo "fcut: not found: $item" >&2
    fi
  done

  mv "$tmp" ~/.fileclip
}

fpaste() {
  [ -f ~/.fileclip ] || { echo "fpaste: file clipboard is empty"; return 1; }

  mode="$(head -n1 ~/.fileclip)"
  count=0

  while IFS= read -r src; do
    [ -n "$src" ] || continue

    if [ ! -e "$src" ]; then
      echo "fpaste: source no longer exists: $src" >&2
      continue
    fi

    if [ "$mode" = "move" ]; then
      if mv -- "$src" .; then
        echo "moved: $src -> $PWD/"
        count=$((count + 1))
      else
        echo "fpaste: failed to move: $src" >&2
      fi
    else
      if cp -a -- "$src" .; then
        echo "pasted: $src -> $PWD/"
        count=$((count + 1))
      else
        echo "fpaste: failed to paste: $src" >&2
      fi
    fi
  done < <(tail -n +2 ~/.fileclip)

  echo "done: $count item(s)"
}

If you like VS Code REST Client, you're going to love LAZYREQUEST

Fredy Sandoval — Wed, 25 Feb 2026 01:41:04 +0000

If you like VS Code REST Client, you're going to love LAZYREQUEST

You already know the best format for API testing: a plain .http file.

What you probably don't have is a dead-simple way to run those files from the terminal (and CI), validate the responses you expect, and get a clean PASS/FAIL signal without adopting an entire new testing framework.

Meet LAZYREQUEST: a lightweight, minimal API Testing Client CLI tool inspired by VS Code REST Client syntax. It recursively discovers .http and .rest files, sends the requests, and compares actual responses against the expected responses you declare in the same template.

Site | npm | GitHub

If you've ever thought:

"My API smoke tests should be as easy as writing an HTTP request."
"I want contract-ish checks without standing up a whole test harness."
"Why does 'try this endpoint' live in Slack instead of in the repo?"

This is for YOU!.

TL;DR

Write requests the same way you already do in VS Code REST Client: method, URL, headers, body.
Optionally declare an expected response block right in the file (status + headers + body).
Run lazyrequest on a folder. It finds everything, executes fast (concurrent by default), and tells you what broke.
No new syntax.
No heavy GUI.
No learning curve.
No Postman tab explosion.

Just .http files. And power.

No collections. No click-ops. No "where did we store the latest curl command?"

The Problem Nobody Talks About

Let's say you are working on a API and you need to test it, you can quickly write a .http file with something like:

GET http://localhost:8080/health

You can see it's output. It works. It’s clean. It’s readable.

But then:

You need CI integration
You want automated assertions
You want folder-wide execution
You want concurrent runs
You don’t want a browser UI

Suddenly you’re installing a whole testing framework. Yikes...

API Testing: when testing becomes a torture

Most teams already have "API tests" scattered across:

random curl commands in docs
unreadable Postman collections everybody is affraid to touch
a half-finished test suite that only one person understands

LAZYREQUEST makes the happy path boring:

your requests live in the repo as .http / .rest
your expectations live next to the request (when you want assertions)
your terminal becomes the source of truth

A real example (request + expected response)

What If Your .http Files Became Your Test Suite?

That’s exactly what LAZYREQUEST does.

@baseUrl = http://localhost:8080

###
POST {{baseUrl}}/users HTTP/1.1
Content-Type: application/json

{
  "name": "John Doe",
  "email": "john@example.com"
}

###
# Expected response
HTTP/1.1 201 Created
Content-Type: application/json
Location: {{baseUrl}}/users/123

{"ok":true,"id":123}

Then run:

$ lazyrequest

And you instantly know:
✓ Passed/Failed Status
✓ Headers correct
✓ JSON structure correct

Or exactly what failed.

Now your repo contains something you can:

review in a PR
run locally
run in CI
keep up-to-date without ceremony

Try It. Break It. Star It. ⭐

Installation:

npm i -g lazyrequest

Or clone + build with Bun:

git clone https://github.com/FredySandoval/lazyrequest.git
bun build ./src/index.ts --compile --minify --outfile lazyrequest --target bun

Or download the binary from GitHub releases.
https://github.com/FredySandoval/lazyrequest

npm:
https://www.npmjs.com/package/lazyrequest

Final Thought

The best tools don’t invent new syntax.
They unlock the power of what you’re already using.
LAZYREQUEST doesn’t replace your workflow.
It upgrades it. 🚀

Google OAuth2 for Dummies

Fredy Sandoval — Mon, 12 Jun 2023 18:07:27 +0000

The Full code is at the bottom.

TLDR: In this tutorial we will Authenticate an Application using Google OAuth2. It loads credentials from a local JSON file, creates an OAuth2 client with those credentials, and sets up a few HTTP routes to handle the authentication process.

Questions to be answered:

1. How authenticate an app using Google OAuth2 in NodeJS?

You use the googleapis npm package to create an OAuth2 client with your app's credentials. Generate an authorization URL and redirect users there to grant your app permissions. When they're redirected back to your app, exchange the "code" they bring for access and refresh tokens.

2. How do you load credentials from a JSON file in Google APIs?

You can use the fs module's readFileSync function to read the contents of the file. Then, use JSON.parse to parse the contents into a JavaScript object.

3. What are the Google API scopes?

Scopes define the permissions your app is requesting from users. This script requests permission to send Gmail messages on the user's behalf.

PART 1

Creating credentials

a. Go to Google Console > Credentials
https://console.cloud.google.com/apis/credentials

b. Create a new Credential of type OAuth client ID

c. Select type Desktop and give any name you want

d. Save the JSON file (client_secret_xxx…) in the root folder of
the project

IMPORTANT!

You must add the email addresses of the people that will use
the application, including yours. Otherwise that person won’t
be able to use the application.

You also must modify the JSON secret file (the file you just
downloaded "client_secret_xxx…")
At the end of the file you will find “redirect_uris”, you need to
modify it like this:

PART 2

We're going to break down a piece of code that allows your application to interact with Google APIs using OAuth2 for authentication. This script involves several important Node.js modules like googleapis, fs, path, and express. Let's get started!

First off, install the necessary packages.

npm init -y
npm install express googleapis

now let's import some essential modules:

const { google } = require('googleapis');
const fs = require('fs');
const path = require('path');

google is part of googleapis, which lets us interact with Google's services. fs is a built-in Node.js module to work with the file system, and path helps us with file paths.

Now, we define some constants:

const CREDENTIALS_FOLDER  = './'; // location of credentials
const SCOPES              = ['https://www.googleapis.com/auth/gmail.send'];

CREDENTIALS_FOLDER is the location of our Google API credentials file. SCOPES is an array that specifies what permissions our application requests from users. Here, we're asking to send Gmail messages on behalf of the user.

The next part of the script involves loading our Google API credentials:

let credentials;
try {
  const files = fs.readdirSync(CREDENTIALS_FOLDER);
  const credentialsFile = files
    .find(file => file.startsWith('client_secret_') && file.endsWith('.json'));
  const credentialsPath = path.join(__dirname, CREDENTIALS_FOLDER, credentialsFile);
  const file = fs.readFileSync(credentialsPath, 'utf8');
  credentials = JSON.parse(file);
} catch (error) {
  console.log("unable to read file, can't continue");
}

This script looks for a file that starts with client_secret_ and ends with .json (this is your Google API credentials file). It then reads the file and parses it as JSON. If something goes wrong (like if the file doesn't exist), it logs an error message.

Next, we validate our credentials:
But why? it is very common that we or somebody loads the incorrect credentials type, Google has different credentials, and validating we have the right ones will save hours of debugging.

const REQUIRED_CREDENTIALS_PROPERTIES = [
  'client_id', 'project_id', 'auth_uri', 'auth_provider_x509_cert_url', 'token_uri', 'client_secret', 'redirect_uris'
];
REQUIRED_CREDENTIALS_PROPERTIES.forEach(prop => {
  if (!(prop in credentials.installed)) 
    throw new Error(`Property ${prop} not found in credentials`);
});

We have a list of all the properties that should be in our credentials object, and we make sure that each one is there. If not, we throw an error.

Now we create an OAuth2 client:

const { installed: { client_id, client_secret, redirect_uris } } = credentials;
const oAuth2Client = new google.auth.OAuth2(client_id, client_secret, redirect_uris[0]);
let authUrl = oAuth2Client.generateAuthUrl({
  access_type: 'offline',
  scope: SCOPES
});

We pull out the necessary parts of our credentials and create an OAuth2 client. We then generate a URL (authUrl) where users will grant our application the permissions we requested.

Next, we set up an Express application:

const express = require('express');
const app = express();

Express is a framework that makes it easier to handle HTTP requests and responses in Node.js.

We define three routes. The first ('/') sends users to the authUrl we generated earlier:

app.get('/', (req, res) => {
  res.send(`<a href="${authUrl}">Authorize</a>`);
});

The second (/oauth2callback) is the "callback URL". After users grant permissions, Google redirects them here with a special "code". We exchange that code for access and refresh tokens, which allow us to make authorized requests on behalf of the user:

app.get('/oauth2callback', async (req, res) => {
  const { code } = req.query;
  const { tokens } = await oAuth2Client.getToken(code);
  oAuth2Client.setCredentials(tokens);
  res.redirect('/authenticated');
});

The third route ('/authenticated') simply confirms that the user has been authenticated:

app.get('/authenticated', (req, res) => {
  res.send('You are authenticated now!');
});

Next, we define two "middleware" functions to handle requests that don't match any routes and to handle errors:

function notFound(req, res, next) {
  res.status(404);
  const error = new Error('Not Found - ' + req.originalUrl);
  next(error);
}
function errorHandler(err, req, res, next) {
  res.status(res.statusCode || 500);
  res.json({
    message: err.message,
    stack: err.stack
  });
}
app.use(notFound);
app.use(errorHandler);

These functions provide helpful error messages to users and developers.

Finally, we make our app listen on a specific port:

var interfaces = require('os').networkInterfaces(), localhostIP;
for (var k in interfaces) {
    for (var k2 in interfaces[k]) {
        let ipFamily = interfaces[k][k2].family;
       if ( ipFamily === 'IPv4' || ipFamily === 4 && !interfaces[k][k2].internal) {
          localhostIP = interfaces[k][k2].address;
       }
   }
}
const port = process.env.PORT || 5000;
app.listen(port, () => {
    console.log(`Listening on http://${localhostIP}:${port}`);
});

This script starts our app listening on the port specified by the environment variable PORT, or 5000 if PORT isn't defined. The server's address is logged to the console when the server starts.

And that's it! You've just learned how to set up a simple OAuth2 authentication flow with Google APIs and Express. It's not so difficult when you break it down, right? Happy coding!

Full code

const { google }          = require('googleapis');
const fs                  = require('fs');
const path                = require('path');
const CREDENTIALS_FOLDER  = './';
const SCOPES              = ['https://www.googleapis.com/auth/gmail.send'];

/* GLOBAL VARIABLES*/
let credentials;


// ----------  OAUTH2 CLIENT ----------------
// Load client secrets into "credentials"
try {
  const files = fs.readdirSync(CREDENTIALS_FOLDER);
  const credentialsFile = files
    .find(file => file.startsWith('client_secret_') && file.endsWith('.json'));

  if (!credentialsFile) throw new Error('credentials file not found');

  // const credentialsPath = CREDENTIALS_FOLDER + credentialsFile;
  const credentialsPath = path.join(__dirname, CREDENTIALS_FOLDER, credentialsFile);
  const file = fs.readFileSync(credentialsPath, 'utf8');
  credentials = JSON.parse(file);
} catch (error) {
  console.log("unable to read file, can't continue");
}

// VALIDATE CREDENTIALS 
const REQUIRED_CREDENTIALS_PROPERTIES = [
  'client_id',
  'project_id',
  'auth_uri',
  'auth_provider_x509_cert_url',
  'token_uri',
  'client_secret',
  'redirect_uris'
];

// Ensure all required properties exist
if (!credentials || !credentials.installed) {
  throw new Error('credentials or installed not found in credentials');
}

REQUIRED_CREDENTIALS_PROPERTIES.forEach(prop => {
  if (!(prop in credentials.installed)) 
    throw new Error(`Property ${prop} not found in credentials`);
});

const { installed: { client_id, client_secret, redirect_uris } } = credentials;
const oAuth2Client = new google.auth.OAuth2(client_id, client_secret, redirect_uris[0]);

let authUrl = oAuth2Client.generateAuthUrl({
  access_type: 'offline',
  scope: SCOPES
});

// ----------  EXPRESS APPLICATION  ----------------
const express = require('express');
const app     = express();

app.get('/', (req, res) => {
  res.send(`<a href="${authUrl}">Authorize</a>`);
});

app.get('/oauth2callback', async (req, res) => {
  const { code } = req.query;
    const { tokens } = await oAuth2Client.getToken(code);
    oAuth2Client.setCredentials(tokens);
    res.redirect('/authenticated');
});

app.get('/authenticated', (req, res) => {
  res.send('You are authenticated now!');
});
// ----------  EXPRESS FALLBACKS  ----------------
function notFound(req, res, next) {
  res.status(404);
  const error = new Error('Not Found - ' + req.originalUrl);
  next(error);
}
function errorHandler(err, req, res, next) {
  res.status(res.statusCode || 500);
  res.json({
    message: err.message,
    stack: err.stack
  });
}
app.use(notFound);
app.use(errorHandler);

// gets the localhost IP address
var interfaces = require('os').networkInterfaces(), localhostIP;
for (var k in interfaces) {
    for (var k2 in interfaces[k]) {
        let ipFamily = interfaces[k][k2].family;
       if ( ipFamily === 'IPv4' || ipFamily === 4 && !interfaces[k][k2].internal) {
          localhostIP = interfaces[k][k2].address;
       }
   }
}

const port = process.env.PORT || 5000;

app.listen(port, () => {
    console.log(`Listening on http://${localhostIP}:${port}`);
});

Explaining the video "Enums Considered Harmful" of Matt Pocock

Fredy Sandoval — Sun, 18 Dec 2022 04:16:14 +0000

I was watching this video by Matt Pocock, but I found really hard to digest and internalize the TypeScript, so I decided to create a little guide, because I learn better when I explain things to others, so here it is.
The TypeScript shown in the video

const LOG_LEVEL = {
   DEBUG: 'debug',
   WARNING: 'warning',
   ERROR: 'error',
} as const;

type ObjectValues<T> = T[keyof T];
type LogLevel = ObjectValues<typeof LOG_LEVEL>

Destructuring...

'typeof' will get you the types

type LOG_LEVEL_TYPE = typeof LOG_LEVEL;
// Hardcoded will be like this:
type LOG_LEVEL_TYPE_2 = {
    readonly DEBUG: "debug";
    readonly WARNING: "warning";
    readonly ERROR: "error";
}

'keyof' will get the keys

type LOG_LEVEL_KEYS = keyof LOG_LEVEL_TYPE;
// Hardcoded will be like this:
type LOG_LEVEL_KEYS_2 = "ERROR" | "WARNING" | "DEBUG"

'type[i]' will get the values

type LOG_LEVEL_VALUES = LOG_LEVEL_TYPE["ERROR" | "WARNING" | "DEBUG"];
// or
type LOG_LEVEL_VALUES_2 = LOG_LEVEL_TYPE[LOG_LEVEL_KEYS];
// Hardcoded will be like this:
type LOG_LEVEL_VALUES_3 = "debug" | "warning" | "error"

For example the variable myLog can only be the VALUES, anything else will throw an error

let myLog: LOG_LEVEL_VALUES;
myLog = 'debug';
myLog = 'warning';
myLog = 'error';

MyLog_2 can only be the KEYS

let myLog_2: LOG_LEVEL_KEYS;
myLog_2 = 'DEBUG';
myLog_2 = 'ERROR';
myLog_2 = 'WARNING';

The previous can also be compressed and written like this:

type LOG_LEVEL_VALUES_4 = typeof LOG_LEVEL[keyof typeof LOG_LEVEL];
// Hardcoded will be like this:
type LOG_LEVEL_VALUES_5 = "debug" | "warning" | "error"

Now explaining the TypeScript will be:

type ObjectValues<T> = T[keyof T];

// Imagine it as a function that returns the values of wherever T is.
function ObjectValues(T:any) {
    return T[Object.keys(T)[0]]
}

for example:

type MyType = {
   myString: 'my string',
   myNumber: 23,
}

let myValue:ObjectValues<MyType>;
myValue = 'my string' // can only be the litteral string,
myValue = 23;         // or the litteral value

Explaining the last part

type LogLevel = ObjectValues<typeof LOG_LEVEL>
// Now imagine this part like we actually execute the function and 
// we passed the types provided by "typeof"
let logLevel = ObjectValues({ myString: 'my string'})

Playground Link

TypeScript: A beginner's guide with emojis 🤗

Fredy Sandoval — Wed, 07 Dec 2022 22:02:32 +0000

Is basically telling what type something is.

For example let say we have a box,
and we want to tell people to only put eggs in the box.

let myBox; // 📦

In real life we would put a sticker in the box saying "only eggs
please 📄", in TypeScript we do the same, we add a "type" saying what something is and only accepts.

  Variable           Type            value
┌────┴─────┐     ┌────┴─────┐      ┌───┴───┐
let myBox_📦  :  onlyEggs_📄   =   "🥚🥚🥚";
               ↑                ↑
               Separator        Assignment operator

There are 3 basic types in TypeScript

let isDone: boolean = false;              // 😀 or 😟

let lines: number   = 42;                 // 0️⃣1️⃣2️⃣3️⃣4️⃣5️⃣...

let name: string    = "John";             // 📃

When it's impossible to know, there is the "Any" type

let notSure: any = 4;                     // 🤷‍♂️ Not sure

notSure = "I'm a string";                 // I can change it later

notSure = false;                         // maybe a boolean

There are typed arrays

let list: number[] = [1, 2, 3];

// or with emojis:
        Only chickens please!
              ┌─┴─┐ 
let chickens: 🐔[] = [🐣,🐤,🐥,🐓];

Alternatively you can use Array which It's same as Type[]

let list: Array<number> = [1, 2, 3];

// or with emojis
let listOfChickens: Array<🐔> = [🐣,🐤,🐥,🐓];

Enumerations also known as enums:

enum Square { Red, Green, Blue };         // 🟥, 🟩, 🟦

// This can be understood better by seeing what Enumerations 
// are compiled to in JavaScript:
Square = { 
           0       :   'Red', 
           1       :   'Green', 
           2       :   'Blue', 
           Red     :    0, 
           Green   :    1, 
           Blue    :    2,
          };

// Now that you know is just an object, 
// you can access it by name or number.
console.log( Square.Green );              //  🟩
console.log( Square[2] );                 //  🟥 

// or in a more complex way
let c: Square = Square.Blue;
console.log( Square[c] );                 //  🟦

Please Comment if you want to see more content like this!
👇 Follow me on Twitter

Story of how I built my side project - MicroDBs -

Fredy Sandoval — Fri, 18 Nov 2022 15:00:00 +0000

One of the dilemmas I always have when building something is the database, but the biggest one is "what if I want to store something really small? or I might delete it later or use it very little" like a score tracker or a views counter or a little Likes button. Is it worth it? to deploy an entire database just to store a few records.

That's when I came up with the idea of creating a free service for creating small collections simple and free MicroDBs, where users can create and manage documents, for small purposes without the hassle of dealing with the database itself.

Basic Idea

Prepare the service to handle thousands collections.
Allow Users to create a collections.
Users can delete and modify the existing collection.
Users can Insert, Find, and update documents.

Building the Frontend

The sketch the layout in Figma

Creating the graphics in Blender

Building the Backend

Solving the project logic in pseudocode

METHOD "POST" 
ROUTE PATH "/createcollection"
1. Check if HTTP request is valid
2. Check if collection already exists
3. Store the collection as independent file
4. Store the collection id in an index

METHOD "DELETE"
ROUTE PATH "/delete"
1. Check if HTTP request is valid.
2. Check if collection exists and load it in memory.
3. Validate if user has permission to delete.
4. Delete the collection and delete entry in index.

METHOD "GET"
ROUTE PATH "/find"
1. Check if HTTP request is valid
2. Check if collection exists and load it in memory.
3. Validate if user has permission to read.
4. Respond to request in JSON

METHOD "POST"
ROUTE PATH "/insert"
1. Check if HTTP request is valid
2. Check if collection exists and load it in memory.
3. Validate if user has permission to insert.
4. Validate schema of new document and insert it if ok.
5. Respond status ok

METHOD "PATCH"
ROUTE PATH "/update"
1. Check if HTTP request is valid
2. Check if collection exists and load it in memory.
3. Validate if user has permission to update.
4. find document in collection
5. Validate schema of new document and insert it if ok.
6. Respond status ok

Node packages

 "dependencies": {
    "ajv": "^8.11.0",
    "bcryptjs": "^2.4.3",
    "cors": "^2.8.5",
    "express": "^4.18.1",
    "express-rate-limit": "^6.4.0",
    "ip-matching": "^2.1.2",
    "ip-range-check": "^0.2.0",
    "is-cidr": "^4.0.2",
    "joi": "^17.6.0",
    "lodash-es": "^4.17.21",
    "lowdb": "^3.0.0",
    "nanoid": "^4.0.0"
  },
  "devDependencies": {
    "axios": "^0.27.2",
    "jest": "^28.1.3",
    "nodemon": "^2.0.19"
  }

Continuous Integration using GitHub

name: Deploy to GCP server

defaults:
  run:
    shell: bash -ieo pipefail {0}

on: [workflow_dispatch]

jobs:
  build:
    runs-on: self-hosted

    steps:
    - uses: actions/checkout@v3
    - name: Install dependencies
      run: npm install
    - run: pm2 restart all

Testing using JEST

it('Create basic collection', async () => {
    const res = await axios.post(`${baseUrl}/createcollection`);
    expect(res.status).toBe(200);
    expect(res).toHaveProperty('data');
});

FINAL RESULT

Check out the code in GitHub

Follow me on Twitter 👇

10 Isometric Illustrations for your next Dev Project

Fredy Sandoval — Fri, 28 Oct 2022 03:16:49 +0000

I made 10 free of any copyright Abstract illustration for your next dev project.

The Images have no background so they can merge with your own background.

1

2

3

4

5

6

7

8

9

10

Link to Download All

👇 Follow me on Twitter

8 illustrations to make Twitter/Instagram dev post rock!

Fredy Sandoval — Wed, 19 Oct 2022 20:33:48 +0000

I made this images with no copyright, use them wherever you want.

How to use them? see the example:

pick a catchy title and content and add them to the images. Example:

Cover	Background

1. Mugs

Cover	Background

Download

2. Books

Cover	Background

Download

3. Code

Cover	Background

Download

4. Various Shapes

Cover	Background

Download

5. Spheres

Cover	Background

Download

6. Torus

Cover	Background

Download

7. javascript

Cover	Background

Download

8. python

Cover	Background

Download

👇 Follow me on Twitter

I'll teach you 7 Array methods. (with animations!)

Fredy Sandoval — Tue, 20 Sep 2022 21:22:04 +0000

map

Creates a new array populated with the results of a provided function on every element.

[1, 2, 3].map( n => n * 2 ); // [2, 4, 6]

filter

Creates a Copy of a portion of a given array, filtered down to just the elements from the given array that pass the test, keep in mind that changes of your first array will affect your copy.

[1,2,3].filter( n => n !== 2 ); // [1,3]

find

Stops and returns the first element in the provided array that satisfies the provided testing function, otherwise returns undefined.

[1,2,3].find( n => n == 2 ) // 2

findIndex

Returns the index of the first element that satisfies the provided testing function. Otherwise -1 is returned.

[1,2,3].findIndex( n => n == 2) // 1

fill

Changes all elements in an array to a static value, from a start index (default 0) to an end index (default array.length). It returns the modified array.

[1,2,3].fill('Txt', 1,2) // [1,'Txt', 3]

every

Tests all elements in the array. After finished returns a Boolean value

[2,2,2].every( n => n == 2 ) // true

some

Tests whether at least one element in the array passes the test implemented by the provided function.

[1,2,3].some( n => n == 2) // true

👇 Follow me on Twitter

Renaming lots of files? This trick will save you hours!

Fredy Sandoval — Sat, 17 Sep 2022 19:47:57 +0000

Let's say you have 100 files that are named incorrectly, and you need to change a specific part of it's name.

The Question would be:

How do I rename several files at the same time?

Answer:
You can use a command line interface tool (cli) named Ranger. This tool will allow you to use your favorite text editor, Nano or Vim, to rename files in bulk.

Here are the steps:

Step 0.
Ensure you have Ranger installed, if you don't know how to install it, you can check this article.

Step 1.

In a new terminal, call ranger and select all the files you want to rename with the spacebar.

Step 2.
Once the files are selected, type :bulkrename this will open you an editor with the names of the files in it.

Step 3.
You can start editing the file names, all changes you make to the names will be applied to the actual filenames of your files, once you're done, just close and save it.

You will be prompted two times asking if you want to save and close.

Visual Example:

Ranger File Manager For Newbies (Easy Edition!)

Fredy Sandoval — Fri, 16 Sep 2022 23:25:25 +0000

What is ranger file manager?

ranger is a file manager like Dolphin in Linux or Finder in MacOS that runs in the console or terminal, thought for productivity.

General Usage

How to Install Ranger?

Linux Debian

$ sudo apt install ranger

Linux Arch Based

$ sudo pacman -S ranger

MacOS

$ brew install ranger

How to open Ranger File Manager?

After being installed just type "ranger"

$ ranger

how to quit or exit Ranger?

You can quit ranger in the following ways:

Command	Description
q	exits ranger
Q	exits ranger
ZZ	exits ranger
ZQ	exits ranger
:exit	exits ranger
:quit	exits ranger

How to move around between files?

Command	Description
h	moves one directory to the left
[n]h	moves n directories to the left, example: 3n
l	enters the right
[n]l	jumps n directories to the right, example: 3l

Command	Description
j	moves the selector down
[n]j	moves the selector down n time, example: 2j
k	moves the selector up
[n]k	moves the selector up n time, example: 3k

Command	Description
gg	Move to the top of the list
G	Move to the bottom of the list

The Google Drive API for the very, very beginner.

Fredy Sandoval — Tue, 12 Jul 2022 00:52:23 +0000

An easy to understand guide on how to use the Google Drive API

What its used for
Types of Authentication
- API key
- OAuth client ID
- Service account
Authenticating our Application
- Using API key
- Using Google OAuth client ID
- Using Service account
  - Sending a request
  - Using the API key
  - Using the OAuth client ID
  - File Methods, examples:
  - set root Url
  - copy
  - create
- create a new folder
- Upload a new file
  - delete
  - empty trash
  - export
  - generateIds
  - get
  - list
  - update
  - watch
  - stop

What its used for

In simple words: it help us to send HTTP requests in a way that the Google servers can accept, allowing us to manipulate the the Google Drive files.

Types of Authentication

The first step is to decide the authentication method, here are the option and use cases:

API key

Use this credential to access/get publicly-available data anonymously, this means files set as "anyone with the link", you can't set/insert data just read it. you can safely expose this key to the user, since you can control the request via Google Cloud Platform.
OAuth client ID

Use this credential to authenticate as an end user and access their data. Requires your app to request and receive consent from the user via OAuth, this requires a server in the middle to handle the keys, since this can't be expose to the end user.
Service account

Use this credential to authenticate as a service account or to access files on behalf of Google Workspace. This service accounts can't be accessed using a username or password, you must be careful with the keys since it can compromise your Google Account.

How to Get the keys:

API key

Go to https://console.cloud.google.com/apis/credentials > Create Credentials > API Key

!Alert: This API key is normally exposed to the public, so you may want to restrict the API, because its usage will count towards your account.
OAuth client ID

Go to https://console.cloud.google.com/apis/credentials > Create Credentials > OAuth client ID
Service Accounts

Go to https://console.cloud.google.com/apis/credentials > Create Credentials > Service account

Authenticating our Application

Using API key

const { google } = require('googleapis');

const API_KEY = 'RanD0mK3Y-abcdevwefw-1234567890';

async function main() {
    const drive = google.drive({ version: 'v3', auth: API_KEY });
    console.log(drive);
}

Using Google OAuth client ID

const { google } = require('googleapis');
const fs = require('fs');
const readline = require('readline');
const SCOPES = ['https://www.googleapis.com/auth/drive']; // Allows all scopes 
const TOKEN_PATH = './token.json'; // If this file doesn't exist, will be created later.
const CREDENTIALS_PATH = './client_secret_1234567890.json' // replace name with your secret file
let credentials, token;
// Getting credentials
try {
    const file = await fs.promises.readFile(CREDENTIALS_PATH);
    credentials = JSON.parse(file);
} catch (err) {
    console.error('Unable to read file:', err);
}
const { installed: { client_id, client_secret, redirect_uris } } = credential;
const oAuth2Client = new google.auth.OAuth2(client_id, client_secret, redirect_uris[0]);
// Getting Token
try {
    const file = await fs.promises.readFile(TOKEN_PATH);
    token = JSON.parse(file);
} catch (err) {
    const authUrl = oAuth2Client.generateAuthUrl({
        access_type: 'offline',
        scope: SCOPES,
    });
    console.log('Authorize this app by visiting this url:', authUrl);
    const rl = readline.createInterface({
        input: process.stdin,
        output: process.stdout,
    });
    rl.question('Enter the code from that page here: ', (code) => {
        rl.close();
        oAuth2Client.getToken(code, async (err, r_token) => {
            if (err) reject(err);
            await fs.promises.writeFile(TOKEN_PATH, JSON.stringify(r_token), (err) => {
                if (err) reject(err);
                console.log('Token stored to', `./${TOKEN_PATH}`);
            });
            token = r_token;
        });
    });
}
// Setting token 
oAuth2Client.setCredentials(token);
const drive = google.drive({ version: 'v3', auth: oAuth2Client });

Using Service account

const { google } = require('googleapis');
const path = require('path');

const KEYFILEPATH = path.join(__dirname, 'service.json');
const SCOPES = ['https://www.googleapis.com/auth/drive'];

const auth = new google.auth.GoogleAuth({
    keyFile: KEYFILEPATH,
    scopes: SCOPES,
});
const drive = google.drive({ version: 'v3', auth });

Sending a request

Regardless of the method or programming language we use, the HTTP request that Google will receive, looks like this:

Using the API key

GET /drive/v3/files/AbCdEFGhijklmopr-abcde_fghijl-oqQrstuvWxyZ?fields=kind%2C%20id%2C%20name&key=Abcdefghij-KmnloprstuVwxyZ HTTP/1.1
Host: googleapis.com
User-Agent: google-api-nodejs-client/0.7.2 (gzip)
Accept: application/json
Accept-Encoding: gzip
X-Forwarded-For: 190.191.192.193
X-Forwarded-Proto: https

Using the OAuth client ID

GET /drive/v3/files/17qEQsVNm-XWtdGSWy2_p0-pyoLaZS0mq16L1mKX2it4?fields=kind%2C%20id%2C%20name HTTP/1.1
Host: googleapis.com 
User-Agent: google-api-nodejs-client/0.7.2 (gzip)
Accept: application/json
Accept-Encoding: gzip
Authorization: Bearer ya12.RaNdOmStRinG1234RaNdOmStRinG1234RaNdOmStRinG1234-RaNdOmStRinG1234_RaNdOmStRinG1234_RaNdOmStRinG1234
X-Forwarded-For: 190.191.192.193
X-Forwarded-Proto: https

Sending the same request with the Google APIs Node.js Client package will look like this:

// The authentication was done using the previous methods
const path_parameters = {
    fileId: 'AbCdEFGhijklmopr-abcde_fghijl-oqQrstuvWxyZ',
    fields: 'kind, id, name',
}
const result = await drive.files.get(path_parameters, options);

File Methods, examples:

set root Url

You can send the HTTP request to a different server, for example you can send the request to a ngrok https server tunneling ncat to output all the incoming requests, this can be useful if you want to see what exactly is receiving the server.

const options = {
    rootUrl: 'https://www.googleapis.com',
}
// const options = {
//     rootUrl: 'https://1234-199-199-199-199.ngrok.io/'
// }

copy

const parents = ['YOUR_PARENT_ID_IN_ARRAY'];
const fileId = 'YOUR_ID_OF_THE_FILE_TO_BE_COPIED';
const name = 'YOUR_NEW_NAME';
const path_parameters = {
    fileId: fileId,
    fields: 'kind, id, name',
    resource: {
        name: name,
        parents: parents,
    },
}
const result = await drive.files.copy(path_parameters, options);

create

create a new folder

const parents = ['YOUR_PARENT_FOLDER_OPTIONAL'];
const name = 'YOUR_NEW_FOLDER_NAME';
const path_parameters = {
    resource: {
        name: name, 
        mimeType: 'application/vnd.google-apps.folder',
        parents: parents,
    },
    fields: 'kind, id, name',
}
const result = await drive.files.create(path_parameters, options);

Upload a new file

const path_parameters = {
    resource: {
        name: 'YOUR_NEW_FILE_NAME',
        parents: ['YOUR_PARENTS_IDs_OPTIONAL'],
    },
    media: {
        body: 'YOUR_READABLE_STREAM',
    },
    fields: 'kind, id, name',
}

const result = await drive.files.create(path_parameters, options);

delete

const path_parameters = {
    fileId: 'YOUR_FILE_ID',
    fields: 'kind, id, name',
}
const result = await drive.files.delete(path_parameters, options);

empty trash

await drive.files.emptyTrash({});

export

For a list of avaiable mimeTypes available visit this link

const path_parameters = {
    fileId: 'YOUR_FILE_ID',
    mimeType: 'THE MIMETYPE',
    fields: 'kind, id, name',
}
const options = {
    responseType: 'stream',
    rootUrl: 'https://www.googleapis.com',
}
const result = await drive.files.export(path_parameters, options);

generateIds

const fields = 'kind, space, ids';
const path_parameters = {
    count: 3, // the number of IDs you want
    fields: fields,
}
const result = await drive.files.generateIds(path_parameters, options);

get

const path_parameters = {
    fileId: 'YOUR_FILE_ID',
    fields: 'kind, id, name',
}
const result = await drive.files.get(path_parameters, options);

list

For a list of query string parameters visit this link

const fields = "kind, nextPageToken ,files(kind, id, name)";
const query = "YOUR_QUERIES";
const nextPageToken = "TO_CONTINUE_WITH_A_PREVIOUS_LIST";
const path_parameters = {
    q: query,
    pageSize: 5, // Number of files returned
    fields: fields,
    pageToken: nextPageToken, // optional
}
const listFiles = await drive.files.list(path_parameters, options);

update

const path_parameters = {
    fileId: "YOUR_FILE_ID",
    fields: 'kind, id, name',
    resource: {
        trashed: true, // This will send the file to trash
        name: 'YOUR_NEW_FILE_NAME'
    },
}
const result = await drive.files.update(path_parameters, options);

watch

This will send a HTTP request to the address every time the file is modified

// use https://github.com/uuidjs/uuid to generate a unique id
const channelId = "01234567-89ab-cdef-0123456789ab";
const path_parameters = {
    fileId: 'THE_ID_OF_THE_FILE_YOU_WANT_TO_WATCH',
    supportsAllDrives: true,
    supportsTeamDrives: true,
    requestBody: {
        id: channelId,
        type: "web_hook",
        address: "https://example.com/webhook",
        payload: true,
    },
}
const result = await drive.files.watch(path_parameters, options);

stop

This will stop or unwatches the provious watch file

const channelId = "01234567-89ab-cdef-0123456789ab";
const path_parameters = {
    requestBody: {
        id: channelId,
        // The watch function returns this value
        resourceId: 'abcdeF-GHIJKLMNOPQRSTUVW',
    },
}
const result = await drive.channels.stop(path_parameters, options);

Check my repo for the code github.com/FredySandoval/google-drive-api-usage-examples

DEV Community: Fredy Sandoval

Terminal Tip 🤩 fcopy, fcut, fpaste

If you like VS Code REST Client, you're going to love LAZYREQUEST

If you like VS Code REST Client, you're going to love LAZYREQUEST

TL;DR

The Problem Nobody Talks About

API Testing: when testing becomes a torture

A real example (request + expected response)

What If Your .http Files Became Your Test Suite?

Try It. Break It. Star It. ⭐

Final Thought

Google OAuth2 for Dummies

1. How authenticate an app using Google OAuth2 in NodeJS?

2. How do you load credentials from a JSON file in Google APIs?

3. What are the Google API scopes?

PART 1

Creating credentials

IMPORTANT!

PART 2

Full code

Explaining the video "Enums Considered Harmful" of Matt Pocock

Destructuring...

Now explaining the TypeScript will be:

TypeScript: A beginner's guide with emojis 🤗

Story of how I built my side project - MicroDBs -

Basic Idea

Building the Frontend

Building the Backend

FINAL RESULT

Follow me on Twitter 👇

10 Isometric Illustrations for your next Dev Project

1

2

3

4

5

6

7

8

9

10

👇 Follow me on Twitter

8 illustrations to make Twitter/Instagram dev post rock!

How to use them? see the example:

1. Mugs

2. Books

3. Code

4. Various Shapes

5. Spheres

6. Torus

7. javascript

8. python

👇 Follow me on Twitter

I'll teach you 7 Array methods. (with animations!)

map

filter

find

findIndex

fill

every

some

👇 Follow me on Twitter

Renaming lots of files? This trick will save you hours!

How do I rename several files at the same time?

Ranger File Manager For Newbies (Easy Edition!)

What is ranger file manager?

General Usage

How to Install Ranger?

How to open Ranger File Manager?

how to quit or exit Ranger?

How to move around between files?

The Google Drive API for the very, very beginner.

Table of contents

What its used for

Types of Authentication

API key

OAuth client ID

Service account

How to Get the keys:

API key