Forem: Weasely

Unleashing Tiny-Link: A Swift Node.js Module for URL Shortening with Redis

Weasely — Mon, 13 Nov 2023 17:33:13 +0000

In the world of URL shortening, simplicity meets efficiency with Tiny-Link, a lightweight Node.js module designed for seamless URL shortening and management. Inspired by the need for a straightforward and high-performance solution, Tiny-Link leverages the power of Redis, making it a top-notch choice for developers who prioritize speed and ease of use.

Why Tiny-Link?

Effortless URL Shortening:
Tiny-Link simplifies the process of shortening URLs with just a few lines of code. Say goodbye to complex setups and welcome a hassle-free experience.
Inspired by Simplicity:
The Tiny-Link philosophy revolves around simplicity. The module is crafted to be easy to use, understand, and integrate into your Node.js projects.
Redis Integration:
Redis, the renowned in-memory data store, powers Tiny-Link's storage backend. This ensures lightning-fast read and write operations, making Tiny-Link ideal for scenarios where speed is paramount.
Efficient TTL Management:
Tiny-Link provides efficient Time-To-Live (TTL) management for your shortened URLs. Set expiration times effortlessly, and Tiny-Link takes care of the rest.

Use Cases

User Authentication Links: Simplify the generation of temporary authentication links. With Tiny-Link, create short-lived URLs for user authentication, enhancing security and usability.

const authLink = await tinyLink.shortenUrl('https://your-auth-service.com/user/verify?token=abc123', 3600); // Expires in 1 hour
console.log(authLink); // Example Output: "9aJdbC3eR_-pUz2vLIxq7"

Social Media Sharing: Craft concise and shareable links for social media posts. Tiny-Link excels in creating short and memorable URLs, optimizing the user experience for your audience.

const promoLink = await tinyLink.shortenUrl('https://your-marketing-site.com/summer-sale', 0); // No expiration
console.log(promoLink); // Example Output: "4TddlZPBI5OvE27LDkbwL"

Marketing Campaigns: Manage marketing campaign URLs with ease. Tiny-Link allows you to generate and track short URLs for promotional campaigns, ensuring efficient analytics and engagement monitoring.

const campaignLink = await tinyLink.shortenUrl('https://your-campaign-landing-page.com/new-product', 604800); // Expires in 7 days
console.log(campaignLink); // Example Output: "6TmD1p-N7fz9kROQyYNeW"

Dynamic QR Codes: Integrate Tiny-Link with QR code generators to create dynamic QR codes for printed materials or digital platforms. Provide users with quick access to content without the need for lengthy URLs.

const qrCodeLink = await tinyLink.shortenUrl('https://your-qr-code-content.com/special-offer', 2592000); // Expires in 30 days
console.log(qrCodeLink); // Example Output: "x7l8UcP-2XJpWvR_q0HkD"

How to Get Started

npm install tiny-link

Example Usage:

const { TinyLink } = require('tiny-link');
const Redis = require('ioredis');

// Create an ioredis instance
const yourRedisClient = new Redis();

// Create an instance with your Redis client
const tinyLink = new TinyLink({ client: yourRedisClient });

// Shorten a URL
const shortKey = await tinyLink.shortenUrl('https://example.com');

// Get the original URL
const originalUrl = await tinyLink.getOriginalUrl(shortKey);

Check out the TinyLink GitHub repository for detailed documentation and customization options.

Get Involved
Tiny-Link is open source, and we invite you to contribute, report issues, or suggest enhancements. Join us on our GitHub repository and be part of the Tiny-Link community.

📧 Introducing Email Inspector 📧

Weasely — Sun, 08 Oct 2023 16:35:39 +0000

Are you tired of dealing with invalid or improperly formatted email addresses in your applications? Say goodbye to email hassles with Email Inspector – a powerful Node.js package for email address validation and inspection! 🚀

Key Features:

Validate email addresses with precision, using a comprehensive list of registered Top-Level Domains (TLDs).
Ensure that email addresses adhere to the correct format and structure.
Effortlessly identify whether an email is associated with a business or a free provider.
Customize validation rules with ease, including options for custom free providers and provider exclusions.
Seamlessly integrate Email Inspector into your Node.js applications.

Getting Started Is a Breeze:

npm install email-inspector

const emailInspector = require('email-inspector');

const email = 'user@example.com';

if (emailInspector.validate(email)) {
  console.log('Email is valid');
} else {
  console.log('Email is invalid');
}

Whether you're building registration forms, contact systems, or any application that handles emails, Email Inspector has got your back. Ensure the integrity of your email communication effortlessly!

📦 NPM Package: https://www.npmjs.com/package/email-inspector

Introducing Athena-Express-Plus: Elevating Your Amazon Athena Experience

Weasely — Sat, 23 Sep 2023 07:23:07 +0000

Are you ready to supercharge your Amazon Athena experience? Meet Athena-Express-Plus, the enhanced version of Athena-Express that takes your AWS V3 architecture support to the next level. In this blog post, we'll explore how Athena-Express-Plus seamlessly integrates with the latest AWS services and features, making SQL queries on Amazon Athena a breeze.

Taking Athena-Express to the Next Level
Athena-Express-Plus is a fork of the original Athena-Express project. While it retains the core capabilities of Athena-Express, it goes the extra mile by introducing support for parameterized queries. This feature allows you to inject parameters into your SQL queries, enabling dynamic execution—a game-changer for your Athena workflow.

A Glimpse of Simplicity
One of Athena-Express-Plus's standout features is its ability to simplify SQL query execution in Amazon Athena. Whether you're building a web application or working on other projects, this tool can streamline your workflow. It not only executes SQL queries but also fetches clean JSON results in the same request, making it a versatile choice for developers.

Unveiling Amazon Athena
Before diving deeper into Athena-Express-Plus, let's take a moment to understand Amazon Athena. Launched at AWS re:Invent 2016, Athena revolutionizes data analysis in Amazon S3 using standard SQL. Powered by Presto, an open-source SQL engine developed by Facebook, Athena is a potent tool for querying massive datasets.

Athena combines Presto's power with AWS's serverless and self-managed capabilities, eliminating the need for complex ETL jobs. This means you can quickly analyze large-scale datasets with the SQL skills you already possess.

The Athena-Express-Plus Advantage
So, how does Athena-Express-Plus simplify your Amazon Athena integration? It bundles several essential steps:

Initiating Query Execution: Athena-Express-Plus kicks off your query execution.
Monitoring Progress: It keeps an eye on your query until it's done.
Fetching Results: Once the query finishes, it retrieves the results from Amazon S3.

But Athena-Express-Plus doesn't stop there. It offers additional benefits:

Clean JSON Formatting: Results are neatly formatted into user-friendly JSON arrays.
Error Handling: It handles specific Athena errors like ThrottlingException and NetworkingError gracefully.
Cost Tracking: Get optional statistics, including the cost per query in USD.
Flexible Result Retrieval: Fetch results via Pagination or as a continuous stream.
Synchronous and Asynchronous Modes: Choose the fetching mode that suits your needs.

Without Athena-Express-Plus, you'd have to painstakingly identify the right API methods, piece them together, and manage error handling for each step. Athena-Express-Plus streamlines this integration, freeing you to focus on your core development tasks.

Real-World Application
Athena-Express-Plus finds its most common use case in web applications, acting as a backend for integrating Amazon Athena. It's versatile enough to work in various scenarios, from local applications to AWS Lambda functions.

Here's an example using AWS Lambda:

In this setup, a web frontend triggers an API endpoint hosted on Amazon API Gateway, passing a query request. The API Gateway then invokes a Lambda function equipped with Athena-Express-Plus. It's a streamlined, efficient way to harness the power of Amazon Athena in your applications.

Getting Started with Athena-Express-Plus
Setting up Athena-Express-Plus is straightforward. First, you'll need to configure it, either with simple or advanced settings. Let's look at a basic configuration example:

const athena = new Athena({ region: "REGION" });
const s3 = new S3({ region: "REGION" });
const athenaExpressConfig = { athena, s3, s3Bucket: "s3://my-bucket" };
const athenaExpress = new AthenaExpress(athenaExpressConfig);

If you require more advanced configurations, such as changing the database, workgroup, or encryption settings, Athena-Express-Plus can accommodate those too. It's all about flexibility and making sure it fits your specific needs.

Querying with Athena-Express-Plus
With Athena-Express-Plus configured, you can start querying Amazon Athena effortlessly. Here's a quick example using both object and string notations:

Using Promises:

let myQuery = {
    sql: "SELECT elb_name, request_port, request_ip FROM elb_logs LIMIT 3",
    db: "sampledb"
};

athenaExpress
    .query(myQuery)
    .then(results => {
        console.log(results);
    })
    .catch(error => {
        console.log(error);
    });

Using Async/Await:

(async () => {
    let myQuery = "SELECT elb_name, request_port, request_ip FROM elb_logs LIMIT 3";

    try {
        let results = await athenaExpress.query(myQuery);
        console.log(results);
    } catch (error) {
        console.log(error);
    }
})();

You can also leverage the QueryExecutionId if you have it from a previous execution, which is handy for scenarios like skipping result retrieval or waiting for results asynchronously.

Support for Parameterized Queries
Athena-Express-Plus brings another powerful feature to the table—support for parameterized queries. With parameterized queries, you can inject dynamic values into your SQL queries, making it easy to execute similar queries with different parameters.

Here's a glimpse of how to use parameterized queries:

let myQuery = {
    sql: "SELECT * FROM cloudfront_logs LIMIT ?",
    db: "mydatabase",
    values: ['2']
};

athenaExpress
    .query(myQuery)
    .then(results => {
        console.log(results);
    })
    .catch(error => {
        console.log(error);
    });

In this example, we use placeholders (?) in the SQL query and provide the actual parameter values in the values array.

Get Started with Athena-Express-Plus
Athena-Express-Plus opens up new possibilities for simplifying your Amazon Athena interactions. Whether you're a web developer, data analyst, or cloud enthusiast, this enhanced tool can make your life easier when dealing with Amazon Athena. To get started, check out the Athena-Express-Plus package and dive into the documentation.