Build scalable, and powerful applications, Websites, APIs or automations with no-code, which is extendable with custom code using DoTenX

DoTenX

Cryptocurrency in your pocket, and the inter-blockchain network to put it there. bills itself as the way to use cryptocurrency to make everyday purchases. TenX In their : own words “At TenX we work on making any blockchain asset spendable instantly.” TenX started life as OneBit, a payment card linked to a bitcoin wallet. When Bitcoin began to give up some of it’s cryptocurrency market share, the OneBit team identified an opportunity in developing an exchange platform that could open their project to this broadening market. The platform they came up with is called the . COMIT network The COMIT Network COMIT stands for Cryptographically-secure Off-chain Multi-asset Instant Transaction network. It’s a mouthful. But when you boil it down, It’s just a way to process transactions rapidly, and across blockchain assets. So if you’ve got a customer and they want to pay you in Litecoin but you want to take payment in Bitcoin, COMIT can help. Here’s how: The hash Let’s say you have a math equation that follows a couple of simple rules. When you put the same number into this math equation, you always get the same result. There’s no way way to reverse the equation. Meaning, just because you know the result, doesn’t mean you can figure out the answer. This describes a form of . You’ve probably heard of these things before. They’re kinda a big deal. They mean that you can give me a lock, and I have no way of finding the key. I could try to guess the key but my chances of guessing correctly are so vastly remote that we can pretty much completely rule that out. cryptographic hash function There are a lot of hash functions, each having subtly different properties. There are people who spend their lives examining these functions. They are the basic building blocks of cryptography and cryptocurrencies. Matching So, you want to take payment from your customer. The one with the Litecoin that you’d prefer to turn into Bitcoin. You pick a big crazy number that they can never guess. That’s your secret key. You keep that a secret, but you take that secret key and you run it through a hash function and you get another big crazy number. That’s the number you give to your customer. Now, COMIT runs the COMIT Routing Protocol (CRP). This is the part of the system that analyzes the network and finds the right path for a transaction. There are Nodes on the network, called Liquidity Providers (LP’s) that volunteer funds to aid in transactions. These LP’s are compensated in return for the use of their funds. The CRP is designed to search through these LP’s and find the combination that will result in the fastest, safest, and cheapest possible route for your transaction. Timelocks When the CRP finds the optimal route for your transaction, the sender takes the hash that you sent and forms a contract with the first LP in the route. This contract ties up the necessary funds under a special constraint called a . Hashed TimeLock Contract (HTLC) This HTLC acts as a promise that if the right number is provided in the right timeframe, the LP accepts payment. Otherwise, payment returns to the sender. The sender can’t cancel this contract. It is only cancelled if the timelock is allowed to expire. Setting up the Dominoes This pattern is repeated along the route. Each party enters into one of these HTLC’s with the previous party. Ideally there is only one LP involved. In our case we would hope that the system would be able to find a node that is willing to swap Bitcoin for Litecoin. But in the case of more obscure blockchain assets, we may need to traverse multiple LP’s. Whatever path the protocol defines, the end result is a chain of contracts that guide transactions through the network and into your account. These contracts are designed in such a way that if any one of the transactions fails, the whole transaction chain fails. The trigger to activate these transactions is that secret number that only you possess. With all of these contracts in order, all of the parties involved have open proof that each party is responsible for fulfilling their part of the bargain. At this point you can provide your secret key and each contract takes that secret key and passes it through the same hash function. If the result is equal to the number you provided to the customer in the first place, the transactions are validated. If you want to dig a little deeper, TenX just released on Medium that sheds light on some of the details of how they plan to bootstrap COMIT. an article The Card TenX works with credit card providers to connect this transaction network to a payment card, allowing you to quickly and safely convert cryptocurrency funds into card transactions. Currently, TenX supports Bitcoin, Dash and Ether, but the system is capable of supporting most blockchain assets and the team plans to expand offerings in the future. You can download the TenX mobile wallet and take a look. It’s available for both android and IOS. If you’re in a country where TenX is available you can order a debit card that links to that wallet. The card and services are not yet available in the US. There are plenty of other systems out there that seek to link cryptocurrencies to payment cards: Xapo, bitpay, , etc. There are also other networks designed to provide liquidity between cryptocurrencies: XRP, . Where TenX seems to stand out is in effectively combining the two concepts and integrating an as an incentive to using the system. shift OMG ERC20 token The Token So TenX itself is a payment system, but it also maintains an associated token under the symbol PAY. Where does this token fit in? With a traditional credit card transaction, merchants pay a fee when they accept payment. That fee ranges somewhere between 0.5% and 3%. This fee is split between the merchant’s bank, the credit card processing system, and the card’s issuing bank. With traditional credit cards this fee goes to the card issuer. However, some portion is often returned to the user as an incentive for using the card. That’s where those credit card rewards programs come from. Instead of a rewards program TenX distributes PAY tokens in the amount of 0.1% of purchases. Additionally, a reserve of 0.5% of the payment volume on the network is periodically distributed to holders of PAY tokens in proportion to their holdings. TenX plans to distribute this incentive monthly at first, with hopes of increasing distribution frequency in the future. The Token Sale On June 24th 2017 starting at 9PM Singapore Time, 51% of PAY tokens in existence were released in an Initial Token Sale. Of the remaining tokens, 29% were retained by TenX to fund development. The remaining 20% went to TenX’s founders, employees, and early investors. No new PAY tokens will be created. Other Resources This article is hosted at . If you liked it, please drop in and click around a bit. blockknight.com Watch one of the TenX co-founders, Julian Hosp, do a pretty decent job at trying to . It’s a long video, play it in 2x. explain the COMIT network Crypto Tips Youtube channel offers a . good, quick breakdown The most similar project I can find would appear to be . Monaco

What is TenX? (PAY)

We developed — a useful open-source tool for checking .env files. It helps to find problems in .env files that you may miss at first but later result in incorrect work of applications. Such problems commonly include key duplication, incorrect word delimiter, keys without value, and invalid first characters — just to name a few. We made the tool universal; it can be connected to any project regardless of the programming language. dotenv-linter What is a .env file? A .env file or dotenv file is a simple text file that contains all the environment variables of a project. Storing configuration in the environment variables is one of the tenets of the Manifesto of the Twelve-Factor App. The .env file has a simple key-value format, for example, FOO=BAR. Here's an overview of the key changes made in this new release of dotenv-linter — v3.0.0! API improvements In the previous version, dotenv-linter had several flags, which were essentially separate commands  --fix and --show-checks: This has been leading to a bit of confusion. In the new version, we have fixed this and moved the --fix and --show-checks flags into separate fix and list commands. Comparing .env files Also, in the new version, we added a new compare command, which allows you to compare keys in .env files. Displaying scanned files 👀 With multiple .env files, it was not always clear which ones were checked by dotenv-linter and which ones weren't. This could be happening due to a non-standard file name, or the absence of any problems in these files. In the new version, we have added the display of scanned files. You can disable this using the--quiet/-q flag. Colored output 🌈 To improve usability, we have added a colored warning display. You can disable color output using the --no-color flag. Support for multi-line values 💪 Multi-line values can be stored in .env files. Now, dotenv-linter does not display warnings for multiline values wrapped in quotes. Support for the export prefix 🔥 In the new version, we added support for the export prefix and now dotenv-linter does not display any warnings. Support for spaces 🙌 Another improvement is the support for spaces in values, wrapped in quotes. Now, for such values, dotenv-linter will not display warnings. Improved validation 👌 Also, we fixed an issue where dotenv-linter did not display all warnings at once. Performance improvements 🚀 Last but not least, we have improved the performance of the already fast dotenv-linter. The maximum start time has decreased from 9.3 ms to 4.3 ms (by more than 50%). To check this, we made a benchmark using the hyperfine utility. These are all the key changes that are included in the new v3.0.0 release. Thanks to everyone who contributed! You can support the project by starring or sponsoring it on GitHub. . Previously published at https://evrone.com/dotenv-linter-v300. The author of the story is the Chief Editor at Evrone

dotenv-linter v3.0.0: Identify Errors In .env Files

Find dotenv-linter on Github! When developing applications, we always try to stick to the Manifesto of Twelve Factors. This approach helps you to avoid a number of the problems associated with the ongoing support of applications throughout their lifecycle. One of the principles of the manifesto is that all settings should be stored in environment variables, allowing you to alter them for different environments (development, automated testing, staging/QA, production) without changing the code. However, during development, dealing with all of these variables can quickly become cumbersome. As a project grows, it's typical for the list of environment variables it uses to grow with it, resulting in unwieldy command lines such as these: $ RAILS_ENV=development REDIS_URL=redis: //redis:6379 DATABASE_URL=postgres://postgres:postgres@db:5432 bundle exec rails server Fortunately, there's a solution: . They provide a convenient way to store all environment variables in one place, and there are straightforward libraries in (including Ruby, Elixir, Python, Go, and Rust) for working with them: all they do is load the variables from the file when the application starts. .env files many languages However, it's not always plain sailing. Just like in the real world, your environment needs looking after. Sometimes, problems creep in without you noticing which may impact how your application works. What kind of problems? Well, for example: The more variables that you need to set for your application, the higher the chances you have of accidentally setting the same variable twice — when this happens, the new variables will typically overwrite the old values, but which one did you mean? And when you need to make a change, will you spot the duplicate? Key duplication. Multi-word environment variable names use an underscore as a separator character (if one is used at all) — but it's easy to accidentally type a hyphen instead of an underscore and not notice it until much later. Incorrect word delimiter. A common tactic is to add a placeholder to a .env file — a variable with no value, to be filled in later; this works great, as long as you remember to go back and add the value in! Key without value. Environment variables should begin with a upper-case letter or an underscore. Invalid first character. By convention, application environment variables are always all-uppercase. Lowercase keys. Stray spaces, especially between the variable name and equals sign, can cause problems depending on how the variables are loaded. Spaces. It's not a technical requirement for libraries to use .env files properly, but we've found that when they're sorted by key, it's a lot easier to spot some of the errors described above. Sorting by key. All of the problems described are situations we've run into working on real projects. For that reason, dotenv-linter was created, a tool to check .env files for problems, that could be used as part of your day-to-day workflow! A lightning-fast checking tool, or "linter", for .env files, is developed as an open source project by Mikhail Grachev, Evrone’s software engineer. Linter tools are named after the pieces of fluff that you sometimes find stuck to your clothes and use a lint roller or sticky tape to remove: they don't necessarily do any harm, but they're not especially desirable, either. In contrast to looking for real-life lint on clothes, linter tools often look for things which can do harm, or at the very least are ambiguous enough to be firmly recommended against — such as our list above, which of course dotenv-linter handles all of (and blazingly quickly). Installation dotenv-linter is written in Rust, but you don't need to have anything to do with Rust to use it — it works with any project with .env files. Pre-built binaries are available for Linux and macOS, which you can download from Github. dotenv-linter + reviewdog You can easily integrate dotenv-linter with reviewdog, the automated code-review tool that works with GitHub and GitLab. Just pipe the output of dotenv-linter into reviewdog using the dotenv-linter format: $ dotenv-linter | reviewdog -f=dotenv-linter -diff= "git diff master" On GitHub, you can easily enable dotenv-linter and reviewdog on your project with a ready-made GitHub Action. Supporting open-source We're very happy to support the open-source projects our developers work on in any way that we can, and dotenv-linter is of course no exception, and we're pleased to have contributed the logo and brand identity to the project of our software developer Mikhail Grachev. The logo consists of an upturned letter “L”, reshaped to resemble lightning — representing the sheer speed of dotenv-linter — and we've used a red-orange hue that symbolises Rust, the language the linter's written in. If you know Rust, and can think of ways that dotenv-linter can be improved, we'd be very happy to see you join us and help make it better for everyone. And, if you find yourself in need of developing a new useful tool, like a linter for checking code for your project, just reach out to us! Also published at https://evrone.com/dotenv-linter-v220 . The author of the story is the chief editor at Evrone .

We open sourced dotenv-linter: a lightning-fast linter for .env files, written in rust

We have developed — a useful tool for checking .env files. It helps to find problems in .env files that you might miss at first, but which later may result in incorrect work of applications. dotenv-linter We have made the tool universal, it can be connected to any project regardless of the programming language. We've just released a new version of dotenv-linter — v2.2.0, and here is an overview of the key changes included in this release! Fixing warnings 🔥 Previously, dotenv-linter could only find problems in .env files: $ dotenv-linter
.env: DuplicatedKey: The FOO key is duplicated
.env: UnorderedKey: The BAR key should go before the FOO key 2 3 Now, it can fix them right away with the new --fix/-f argument: $ dotenv-linter --fix
Original file was backed up to: .env: DuplicatedKey: The FOO key is duplicated
.env: UnorderedKey: The BAR key should go before the FOO key

All warnings are fixed. Total: ".env_1601378896" 2 3 2 Making a backup 💪 Fixing problems in .env files is cool, but dotenv-linter creates a backup for each of the files, just in case. You can enable this feature, or disable it using the --no-backup argument — it's up to you: $ dotenv-linter --fix --no-backup

.env: DuplicatedKey: The FOO key is duplicated
.env: UnorderedKey: The BAR key should go before the FOO key

All warnings are fixed. Total: 2 3 2 Support for control comments 🕹 Previously, checks could be disabled globally using the --skip/-s argument: $ dotenv-linter --skip UnorderedKey EndingBlankLine
.env: DuplicatedKey: The FOO key is duplicated

Found problem 2 1 Displaying the total number of problems 👀 When checking several .env files, there was often not enough information provided about how many problems had been found in all files. We have added this information: $ dotenv-linter
.env: DuplicatedKey: The FOO key is duplicated
.env: UnorderedKey: The BAR key should go before the FOO key
.env.test: LeadingCharacter: Invalid leading character detected

Found problems 2 3 1 3 We have also added the new argument --quiet/-q to disable this: $ dotenv-linter --quiet
.env: DuplicatedKey: The FOO key is duplicated
.env: UnorderedKey: The BAR key should go before the FOO key
.env.test: LeadingCharacter: Invalid leading character detected 2 3 1 Installing the latest version from the repository 🍺 The ability to install the latest version from the repository via Homebrew was added: $ brew install --HEAD dotenv-linter/tap/dotenv-linter These are all the key changes in the project that were included in the new v2.2.0 release. More information you can find in the changelog: v2.2.0. https: //github.com/dotenv-linter/dotenv-linter This release wouldn't have been possible without the help of 19 talented developers! How can you support the project? It's very simple - just give us a star on GitHub. Dotenv-linter is not just a linter for .env files — it is also a friendly open-source project with the purpose of helping others learn Rust using a simple, but useful tool. In addition to studying Rust, this project has another goal — to promote love for open-source, help you with the first steps in it, and give an opportunity to contribute to the open-source project written on Rust. We act as a mentor within this project and help developers follow the path of a novice contributor from start to the top.

Find and Fix Problems in .env Files With Dotenv-linter v2.2.0

Using Firebase Authentication with the Latest Next.js Features

সর্বশেষ Next.js বৈশিষ্ট্য সহ Firebase প্রমাণীকরণ ব্যবহার করা

Verwenden der Firebase-Authentifizierung mit den neuesten Next.js-Funktionen

Uso de la autenticación de Firebase con las últimas funciones de Next.js

Utilisation de l'authentification Firebase avec les dernières fonctionnalités Next.js

नवीनतम Next.js सुविधाओं के साथ फायरबेस प्रमाणीकरण का उपयोग करना

Usando o Firebase Authentication com os recursos Next.js mais recentes

Использование аутентификации Firebase с новейшими функциями Next.js

Firebase Kimlik Doğrulamasını En Son Next.js Özellikleriyle Kullanma

Sử dụng Xác thực Firebase với các tính năng Next.js mới nhất

将 Firebase 身份验证与最新的 Next.js 功能结合使用

This is a detailed analysis of how to make a reset for a user when he has forgotten his password and how to send emails from Node JS and validate sending messages. Most of us have experienced the account recovery process at least once — when we forget a password, there’s a need for procedures to create a new one and regain access to the system. This article focuses on implementing such a process using Node.js, Knex, and some undisclosed tools, alongside Express to handle routes and perform the necessary operations. We’ll cover the router implementation, handling URL parameters, determining what to send to the user when only an email or phone number is available as proof, managing email submissions, and addressing security concerns. Forgot Password Flow Before diving into coding, I’d like to ensure that we’re working with the same codebase, which you can access from my public . We will upgrade step by step to implement the forgot password flow. For email transport, we will utilize Google’s email service. repository on GitHub Now, take a look at the schema of the forgot password flow. The server will be responsible for sending emails to the user mailbox containing a valid link for password resetting, and will also validate the token and user existence. Packages and Migration To begin utilizing the email service and sending emails with Node.js, we need to install the following packages in addition to our existing dependencies: npm i --save nodemailer handlebars : Powerful module that allows to send emails easily using SMTP or other transport mechanisms. Nodemailer : Handlebars is a popular templating engine for JavaScript. It will allow us to define templates with placeholders that can be filled with data when rendering. Handlebars Now, we need to create the migration, so in my case, I have to add a new column to table: forgot_password_token users knex migrate:make add_field_forgot_password_token -x ts and in the generated file, I set the code: import type { Knex } from 'knex';

export async function up(knex: Knex): Promise<void> {
  return knex.schema.alterTable('users', table => {
    table.string('forgot_password_token').unique();
  });
}

export async function down(knex: Knex): Promise<void> {
  return knex.schema.alterTable('users', table => {
    table.dropColumn('forgot_password_token');
  });
} Migration for Forgot Password Token in Users table and then migrate the latest file: knex migrate:knex So now we can set to the table our users forgot_password_token Routers To manage controllers responsible for handling the logic of password forgetfulness and resetting, we must establish two routes. The first route initiates the forgot password process, while the second handles the reset process, expecting a token parameter in the URL for verification. To implement this, create a file named within the directory, and insert the following code: forgotPasswordRouter.ts src/routes/ import { Router } from 'express';
import { forgotPasswordController } from 'src/controllers/forgotPasswordController';
import { resetPasswordController } from 'src/controllers/resetPasswordController';

export const forgotPasswordRouter = Router();

forgotPasswordRouter.post('/', forgotPasswordController);
forgotPasswordRouter.post('/reset/:token', resetPasswordController); Forgot Password Router Two controllers will manage the logic for sending emails and resetting the password. Forgot Password Controller When the client forgets his password he has no session, which means we can’t get user data except email or any other security identifiers. In our case, we are sending an email to handle a password reset. That logic we’re going to set into the controller. forgotPasswordRouter.post('/', forgotPasswordController); Remember the ‘forgot password?’ link below the login form usually in the UI of any clients in the login form? Clicking on it directs us to a view where we can request a password reset. We simply input our email, and the controller handles all the necessary procedures. Let’s examine the following code: import { Request, Response } from 'express';
import { UserModel } from 'src/models/UserModel';
import type { User } from 'src/@types';
import { TokenService } from 'src/services/TokenService';
import { EmailService } from 'src/services/EmailService';

export const forgotPasswordController = async (req: Request, res: Response) => {
  try {
    const {
      email,
    }: {
      email: string;
    } = req.body;

    const user = await UserModel.findByEmail(email);

    if (user) {
      const token = await TokenService.sign(
        {
          id: user.id,
        },
        {
          expiresIn: '1 day',
        }
      );
      await user.context.update({ forgot_password_token: token });
      await EmailService.sendPasswordResetEmail(email, token);
    }

    return res.sendStatus(200);
  } catch (error) {
    return res.sendStatus(500);
  }
}; Forgot Password Controller From the body, we going to get an email, and then we will find the user using . If the user exists, we create a JWT token using and save the token to the user with an expiration of 1 day. Then we will send the message to the email with a proper link together with a token where the user will be able to change his password. UserModel.findByEmail TokenService.sign forgot_password_token Google Setup To be able to send the email, we have to create our new email address which will be a sender. Let’s go to Google, to create a new email account, and then, when the account is created, proceed to the link. You can find it on the top right by clicking on avatar. Then, on the left menu, click on the item, and then press . Below you will find the section, click on the arrow: Manage your Google Account Security 2-Step Verification App passwords Input the name that needs to be used. In my case, I set and press . Nodemailer Create Copy the generated password, and set it to your file. We need to set to file two variables: .env MAIL_USER="mygoogleemail@gmail.com"
MAIL_PASSWORD="vyew hzek avty iwst" Of course, to have a proper email like , you have to set up Google Workspace or AWS Amazon WorkMail together with AWS SES, or any other services. But in our case, we are using a simple Gmail account for free. info@company_name.com Email Service With the file prepared, we are ready to set up our service for sending emails. The controller will use the service with the generated token and the recipient email address for our message. .env await EmailService.sendPasswordResetEmail(email, token); Let’s create and define the class for the service: src/services/EmailService.ts export class EmailService {} And now as initial data, I have to get the environment to use with : nodemailer import process from 'process';
import * as nodemailer from 'nodemailer';
import * as dotenv from 'dotenv';

dotenv.config();

export class EmailService {
  private static transporter: nodemailer.Transporter;
  private static env = {
    USER: process.env.MAIL_USER,
    PASS: process.env.MAIL_PASSWORD,
  };
} Email Service We have to take care of service initialization. I wrote about it before in my previous . Here is an example: article import { TokenService } from 'src/services/TokenService';
import { RedisService } from 'src/services/RedisService';
import { EmailService } from 'src/services/EmailService';

export const initialize = async () => {
  await RedisService.initialize();
  TokenService.initialize();
  EmailService.initialize();
}; Initializing Services Now, let’s proceed with creating the initialization within our class: EmailService import process from 'process';
import * as nodemailer from 'nodemailer';
import * as dotenv from 'dotenv';

dotenv.config();

export class EmailService {
  private static transporter: nodemailer.Transporter;
  private static env = {
    USER: process.env.MAIL_USER,
    PASS: process.env.MAIL_PASSWORD,
  };

  public static initialize() {
    try {
      EmailService.transporter = nodemailer.createTransport({
        service: 'gmail',
        auth: {
          user: this.env.USER,
          pass: this.env.PASS,
        },
      });
    } catch (error) {
      console.error('Error initializing email service');
      throw error;
    }
  }
} Email Service Initialization There is initialization , a method provided by the library. It creates a transporter object that will be used to send our emails. The method accepts an options object as an argument where you specify the configuration details for the transporter. nodemailer.createTransport() nodemailer We are using Google: specifies the email service provider. Nodemailer provides built-in support for various email service providers, and indicates that the transporter will be configured to work with Gmail's SMTP server. service: 'gmail' gmail For authentication , it’s necessary to set the credentials that are required to access the email service provider's SMTP server. auth For should be set to the email address from which we are going to send emails, and that password has been generated in the Google account from App Passwords. user Now, let’s set the last part of our service: import process from 'process';
import * as nodemailer from 'nodemailer';
import * as dotenv from 'dotenv';
import { generateAttachments } from 'src/helpers/generateAttachments';
import { generateTemplate } from 'src/helpers/generateTemplate';
import { getHost } from 'src/helpers/getHost';

dotenv.config();

export class EmailService {
  // ...rest code

  public static async sendPasswordResetEmail(email: string, token: string) {
    try {
      const host = getHost();
      const template = generateTemplate<{
        token: string;
        host: string;
      }>('passwordResetTemplate', { token, host });
      const attachments = generateAttachments([{ name: 'email_logo' }]);
      const info = await EmailService.transporter.sendMail({
        from: this.env.USER,
        to: email,
        subject: 'Password Reset',
        html: template,
        attachments,
      });
      console.log('Message sent: %s', info.messageId);
    } catch (error) {
      console.error('Error sending email: ', error);
    }
  }
} Send Password Reset Email Before proceeding, it’s crucial to determine the appropriate host for when the client receives an email. Establishing a link with a token in the email body is essential. import * as dotenv from 'dotenv';
import process from 'process';

dotenv.config();

export const getHost = (): string => {
  const isProduction = process.env.NODE_ENV === 'production';
  const protocol = isProduction ? 'https' : 'http';
  const port = isProduction ? '' : `:${process.env.CLIENT_PORT}`;
  return `${protocol}://${process.env.WEB_HOST}${port}`;
}; Get host For templates, I am using and for that, we need to create in our first HTML template: handlebars src/temlates/passwordResetTemplate.hbs 
<html lang='en'>
  <head>
    <style>
      a { color: #372aff; }  .token { font-weight: bold; }
    </style>
    <title>Forgot Password</title>
  </head>
  <body>
    <p>You requested a password reset. Please use the following link to reset your password:</p>
    <a class='token' href="{{ host }}/reset-password/{{ token }}">Reset Password</a>
    <p>If you did not request a password reset, please ignore this email.</p>
    <img src="cid:email_logo" alt="Email Logo"/>
  </body>
</html> Password Reset Template and now we can reuse this template with the helper: import path from 'path';
import fs from 'fs';
import handlebars from 'handlebars';

export const generateTemplate = <T>(name: string, props: T): string => {
  const templatePath = path.join(__dirname, '..', 'src/templates', `${name}.hbs`);
  const templateSource = fs.readFileSync(templatePath, 'utf8');
  const template = handlebars.compile(templateSource);
  return template(props);
}; Generate Template Helper To enhance our email, we can even include attachments. To do so, add the file to the folder. We can then render this image within the email using the following helper function: email_logo.png src/assets import path from 'path';
import { Extension } from 'src/@types/enums';

type AttachmentFile = {
  name: string;
  ext?: Extension;
  cid?: string;
};

export const generateAttachments = (files: AttachmentFile[] = []) =>
  files.map(file => {
    const ext = file.ext || Extension.png;
    const filename = `${file.name}.${ext}`;
    const imagePath = path.join(__dirname, '..', 'src/assets', filename);
    return {
      filename,
      path: imagePath,
      cid: file.cid || file.name,
    };
  }); Generate Attachments Helper After collecting all of those helpers, we have to be able to send email using: const info = await EmailService.transporter.sendMail({
  from: this.env.USER,
  to: email,
  subject: 'Password Reset',
  html: template,
  attachments,
}); This approach offers decent scalability, enabling the service to employ various methods for sending emails with diverse content. Now, let’s try to trigger the controller with our router and send the email. For that, I am using : Postman The console will tell you that the message has been sent: Message sent: <1k96ah55-c09t-p9k2–8bv2-j25r9h77f763@gmail.com> Check for new messages in the inbox: The link to has to contain the token and host: Reset Password http://localhost:3000/reset-password/<token> The port is specified here because this message pertains to the development process. This indicates that the client responsible for handling forms for password reset will also be operating within the development environment. 3000 Reset Password The token has to be validated on the controller side with TokenService from where we can get the user who sent that email. Let’s recover the router which uses the token: forgotPasswordRouter.post('/reset/:token', resetPasswordController); The controller will only update the password if the token is valid and not expired, as per the expiration time set to one hour. To implement this functionality, navigate to the folder and create a file named containing the following code: src/controllers/ resetPasswordController.ts import bcrypt from 'bcrypt';
import { Request, Response } from 'express';
import { TokenService } from 'src/services/TokenService';
import { UserModel } from 'src/models/UserModel';
import type { User } from 'src/@types';

export const resetPasswordController = async (req: Request, res: Response) => {
  try {
    const token = req.params.token;

    if (!token) {
      return res.sendStatus(400);
    }

    const userData = await TokenService.verify<{ id: number }>(token);
    const user = await UserModel.findOneById<User>(userData.id);

    if (!user) {
      return res.sendStatus(400);
    }

    const newPassword = req.body.password;

    if (!newPassword) {
      return res.sendStatus(400);
    }

    const hashedPassword = await bcrypt.hash(newPassword, 10);
    await UserModel.updateById(user.id, { password: hashedPassword, passwordResetToken: null });

    return res.sendStatus(200);
  } catch (error) {
    const errors = ['jwt malformed', 'TokenExpiredError', 'invalid token'];
    if (errors.includes(error.message)) {
      return res.sendStatus(400);
    }

    return res.sendStatus(500);
  }
}; Reset Password Controller This controller will receive the token, verify it, extract the user ID from the decrypted data, retrieve the corresponding user, acquire the new password sent by the client in the request body, and proceed to update the password in the database. Ultimately, this enables the client to log in using the new password. Conclusion The scalability of the email service is demonstrated through various approaches, such as sending confirmations or success messages, like those indicating a password update and enabling subsequent login. However, managing passwords is a great challenge, particularly when enhancing application security is imperative. There are numerous options available to bolster security, including additional checks before permitting password changes, such as token comparison, email, and password validation. Another option is to implement a PIN code system, where a code is sent to the user’s email for validation on the server side. Each of these measures necessitates the utilization of email-sending capabilities. All implemented code you can find in the . GitHub repository here Please feel free to conduct any experiments with this build, and share your feedback on what aspects you appreciate about this topic. Thank you so much. References Here, you can find several references that I utilized in this article: Repository Initialization Services with Node JS Nodemailer Handlebars Knex Express Postman Also published here

An Account Recovery Process Tutorial Using NodeJS With Knex and Express

Knex এবং Express সহ NodeJS ব্যবহার করে একটি অ্যাকাউন্ট পুনরুদ্ধার প্রক্রিয়া টিউটোরিয়াল

Ein Tutorial zum Kontowiederherstellungsprozess mit NodeJS mit Knex und Express

Un tutorial del proceso de recuperación de cuentas usando NodeJS con Knex y Express

Un didacticiel sur le processus de récupération de compte utilisant NodeJS avec Knex et Express

Knex और Express के साथ NodeJS का उपयोग करते हुए एक खाता पुनर्प्राप्ति प्रक्रिया ट्यूटोरियल

NodeJS と Knex および Express を使用したアカウント回復プロセスのチュートリアル

Knex 및 Express와 함께 NodeJS를 사용하는 계정 복구 프로세스 튜토리얼

Um tutorial do processo de recuperação de conta usando NodeJS com Knex e Express

Учебное пособие по процессу восстановления учетной записи с использованием NodeJS с Knex и Express

Knex ve Express ile NodeJS Kullanan Hesap Kurtarma Süreci Eğitimi

Hướng dẫn quy trình khôi phục tài khoản bằng NodeJS với Knex và Express

使用 NodeJS、Knex 和 Express 进行帐户恢复流程教程

How to Master Authentication and User Flow in Node.js With Knex and Redis

Knex এবং Redis দিয়ে Node.js-এ প্রমাণীকরণ এবং ব্যবহারকারীর প্রবাহ কীভাবে আয়ত্ত করা যায়

So meistern Sie die Authentifizierung und den Benutzerfluss in Node.js mit Knex und Redis

Cómo dominar la autenticación y el flujo de usuarios en Node.js con Knex y Redis

Comment maîtriser l'authentification et le flux d'utilisateurs dans Node.js avec Knex et Redis

Knex और Redis के साथ Node.js में प्रमाणीकरण और उपयोगकर्ता प्रवाह में कैसे महारत हासिल करें

Knex と Redis を使用して Node.js で認証とユーザー フローをマスターする方法

Knex 및 Redis를 사용하여 Node.js에서 인증 및 사용자 흐름을 마스터하는 방법

Como dominar a autenticação e o fluxo do usuário em Node.js com Knex e Redis

Как освоить аутентификацию и поток пользователей в Node.js с помощью Knex и Redis

Knex ve Redis ile Node.js'de Kimlik Doğrulama ve Kullanıcı Akışında Ustalaşma

Cách làm chủ xác thực và luồng người dùng trong Node.js với Knex và Redis

如何使用 Knex 和 Redis 在 Node.js 中掌握身份验证和用户流程

Often, when we build enterprise software solutions meant for independent deployment across different customer environments, we leverage a central image repository. This repository is exposed to the enterprise, who then installs it in their environment. These applications may require variables or files specific to the client's environment, which need to be injected into the image for it to run. As it's impractical to have a separate image for each customer, we use a single image that is customized and injected with required files or variables during deployment. This blog explores how to create a standardized image, inject necessary variables in the form of a file, and deploy it on a cluster. For this we will create a python app, dockerize it, build it and push it to a repository. Once pushed we will be creating standard k8 manifests and Helm charts where we will be injecting our file/variables into it. Kubernetes Application and Image Creation Let's create a simple Python program which retrieves the variables "DB_HOST" and "DB_PASSWORD", then uses them to print both of these variables to the console. import os
from dotenv import load_dotenv

# Load environment variables from .env file
load_dotenv()

db_host = os.getenv("DB_HOST")
db_password = os.getenv("DB_PASSWORD")

print(db_host)
print(db_password) Next, we'll create a Docker image that packages our application using python:3.9-slim and adds all the required packages to the image. The entry point for the image is the above Python file named . Once completed, we'll push our image to an image repository such as ECR or Docker Hub. main.py # Use an official Python runtime as the base image
FROM python:3.9-slim

# Set the working directory in the container
WORKDIR /app

# Copy the current directory contents into the container at /app
COPY . /app

# Install any needed dependencies
RUN pip install --no-cache-dir python-dotenv

# Run the Python script when the container launches
CMD ["python", "main.py"] Creating Deployment Files Once we have the image ready in our preferred image repository, we need to deploy these images on a server. Nowadays, most deployments have moved to Kubernetes, so we'll use it as our deployment platform. Deployment in Kubernetes can be achieved by creating Kubernetes manifests directly or creating HELM charts (or Kustomize), which act like package managers to deploy applications. Let's explore both options: Creating standard manifest files Below, we're creating a deployment of one replica, a service of type NodePort to expose the application, and a secret object that takes the content of our .env file and injects it into the pod when we deploy the application. apiVersion: apps/v1
kind: Deployment
metadata:
  name: python-app
spec:
  replicas: 1
  selector:
    matchLabels:
      app: python-app
  template:
    metadata:
      labels:
        app: python-app
    spec:
      containers:
      - name: your-container-name
        image: your-image-name:your-image-tag
        ports:
        - containerPort: 80
        volumeMounts:
        - name: env-volume
          mountPath: /app/.env
          subPath: .env
      volumes:
      - name: env-volume
        secret:
          secretName: python-app-env-secret
---

apiVersion: v1
kind: Service
metadata:
  name: python-app-service
spec:
  selector:
    app: python-app
  ports:
    - protocol: TCP
      port: 80
      targetPort: 80
      nodePort: 30001
  type: NodePort

---

apiVersion: v1
kind: Secret
metadata:
  name: python-app-env-secret
type: Opaque
data:
  .env: |
    DB_HOST=test
    DB_PASSWORD=password Creating HELM chart To create a helm chart, simply run . For our project here, we'll run . This should create a Python-app folder, which contains the standard HELM template that can be modified according to our requirements. The generated folder should have the following folder/file structure: helm create <app-name> helm create python-app my-chart/
├── charts/
├── templates/
│   ├── deployment.yaml
│   ├── hpa.yaml
│   ├── ingress.yaml
│   ├── NOTES.txt
│   ├── service.yaml
│   └── serviceaccount.yaml
│   ├── hpa.yaml
│   ├── _helpers.tpl
├── values.yaml
└── Chart.yaml We need to create a configmap.yaml file in the templates folder and add the following content to it: # templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
  name: {{ .Release.Name }}-configmap
data:
  .env: |
    DB_HOST={{ .Values.env.DB_HOST }}
    DB_PASSWORD={{ .Values.env.DB_PASSWORD }} The deployments.yaml should look something like this: # templates/deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: {{ include "python-app.name" . }}
  labels:
    app: {{ include "python-app.name" . }}
spec:
  replicas: {{ .Values.replicaCount }}
  selector:
    matchLabels:
      app: {{ include "python-app.name" . }}
  template:
    metadata:
      labels:
        app: {{ include "python-app.name" . }}
    spec:
      containers:
      - name: {{ .Chart.Name }}
        image: "{{ .Values.image.repository }}:{{ .Values.image.tag }}"
        ports:
        - containerPort: 80
        volumeMounts:
        - name: cm-volume
          mountPath: /app/.env
          subPath: .env
      volumes:
      - name: cm-volume
        configMap:
          name: {{ include "python-app.name" . }} The service.yaml: # templates/service.yaml
apiVersion: v1
kind: Service
metadata:
  name: {{ include "python-app.name" . }}
spec:
  selector:
    app: {{ include "python-app.name" . }}
  ports:
    - protocol: TCP
      port: 80
      targetPort: 80
      nodePort: 30001
  type: NodePort The _helpers.tpl should have the following content: # templates/_helpers.tpl.yaml
{{- define "python-app.fullname" -}}
{{- printf "%s-%s" .Release.Name .Chart.Name }}
{{- end }}{{- define "python-app.name" -}}
{{- printf "%s" .Chart.Name }}
{{- end }} In values.yaml, pass your secrets and image repository and tag: # values.yaml
image:
  repository: krishnadutt/my-python-app
  tag: latest
replicaCount: 1
env:
  DB_HOST: test
  DB_PASSWORD: your_database_password For this project, delete the rest of the files in the templates folder. Once done, apply all the manifest files or simply add the helm repository and install it in your k8s. Once deployed, if we execute into the image in Kubernetes, we should see the file and if we search the logs, we should find that .env values are used and those values are printed out by the program. Like my content? Feel free to reach out to my for interesting content and productive discussions. LinkedIn

Enhancing Dockerized Application Deployment: File Passing Strategies with Helm Charts

DOTENX

dotenx.com

1-10 employees

Since n.d.

COMPANY RANKING

DOTENX

EVERGREEN INDEX #4289

Representing this company? Click here to claim and customize this page!

DoTenX WIKI

Apply to get your Tech Company News Page live on HackerNoon.com today!

DOTENX

dotenx.com

1-10 employees

Since n.d.

COMPANY RANKING

DOTENX

EVERGREEN INDEX #4289

RELATED COMPANIESRANK

STORIES ABOUT DOTENX

Representing this company? Click here to claim and customize this page!

DoTenX WIKI

Apply to get your Tech Company News Page live on HackerNoon.com today!