
Aujourd’hui se tient [The Network State Conference](https://lu.ma/tnsconf) à Amsterdam, une conférence consacrée aux sujets d’État-réseaux, aux nouveaux types de société, au nomadisme numérique, …

Des intervenants de marque y seront présents, venant notamment du monde des crypto-monnaies et des nouvelles technologies, par exemple Garry Tan (PDG du [YCombinator](https://www.ycombinator.com)), Vitalik Buterin (fondateur [d’Ethereum](https://ethereum.org)), ou encore Anatoly Yakovenko (co-fondateur de Solana).

Je profite de cette occasion pour présenter la notion d’État-Réseau, prophétisée par [Balaji Srinivasan](https://twitter.com/balajis), à un public francophone (très) peu au courant de cette notion.

Balaji Srinivasan est un _[angel investor](https://fr.wikipedia.org/wiki/Business_angel)_, l’ancien CTO de Coinbase, et l’ancien co-fondateur de [Earn.com](http://Earn.com) (acquis par Coinbase), Counsyl (acquis par Myriad), …, et l’auteur du livre _The Network State_.

Balaji part d’un constat. La technologie a permis la naissance de nouvelles entreprises ([GAFAM](https://fr.wikipedia.org/wiki/GAFAM)), de nouvelles communautés (réseaux-sociaux), et de nouvelles monnaies ([MNBC](https://fr.wikipedia.org/wiki/Monnaie_num%C3%A9rique_de_banque_centrale), crypto-monnaies). Et si la technologie permettait la création de nouveaux États ? C’est l’idée qu’explore Balaji dans son livre _[The Network State](https://thenetworkstate.com),_ publié le 4 juillet 2022.

Mais alors, comment définir un État-réseau ? Pour cela, l’auteur propose plusieurs définitions, en [une phrase](https://thenetworkstate.com/the-network-state-in-one-sentence), en une [image](https://thenetworkstate.com/the-network-state-in-one-image), en [mille mots](https://thenetworkstate.com/the-network-state-in-one-thousand-words) et en [un essai](https://thenetworkstate.com/the-network-state-in-one-essay).

![L’État-réseau en une image](https://book.thenetworkstate.com/assets/dashboard-1729314.png)

L’État-réseau en une image

La définition par l’image nous permet d’approcher un aspect essentiel de la notion d’État-réseau : la décentralisation. L’État-réseau (décentralisé) est à l’État-nation (centralisé), ce que les crypto-monnaies (décentralisées) sont aux monnaies fiduciaires (centralisées).

> _Un État réseau est un réseau social doté d'une innovation morale, d'un sens de la conscience nationale, d'un fondateur reconnu, d'une capacité d'action collective, d'un niveau de civilité en personne, d'une cryptomonnaie intégrée, d'un gouvernement consensuel limité par un contrat social intelligent, d'un archipel de territoires physiques financés par financement participatif, d'une capitale virtuelle, et d'un recensement sur chaîne de blocs qui prouve une population suffisamment nombreuse, un revenu et une empreinte immobilière suffisamment importants pour obtenir une certaine reconnaissance diplomatique. —_ Traduction de la [définition en une phrase](https://thenetworkstate.com/the-network-state-in-one-sentence)

Et vous, dans quel(s) États-réseau aimeriez-vous vous impliquer ? Pour en apprendre davantage, je vous invite à consulter le site [TheNetworkState.com](http://TheNetworkState.com) ou les vidéos disponibles sur la chaîne YouTube _[The Network State Podcast](https://www.youtube.com/@thenetworkstate)_.


L’avènement de l’État-réseau


In this blog post, we will be exploring how to send emails in the NestJS framework using the [Facteur](https://www.facteur.dev) Node.js SDK. NestJS, as you may already know, is a server-side framework for building efficient, reliable, and scalable Node.js server-side applications.

## **Step 1: Prerequisites**

Before you can send emails using the [Facteur](https://www.facteur.dev) Node.js SDK, there are a few things you need:

- A Facteur account
- An API key from Facteur
- A verified sender domain

## **Step 2: Setting up Environment Variables using @nestjs/config**

One of the best practices when working with credentials is to never hard-code them directly into your application. Instead, we should use environment variables. Environment variables allow us to hide sensitive information and keep our configuration separate from our code.

To set up environment variables in NestJS, we can use the @nestjs/config package.

First, install the package:

```bash
npm install @nestjs/config
```

Next, create a **`.env`** file in your root directory and set your API key:

```bash
FACTEUR_API_KEY=your-api-key
```

Then, import the **`ConfigModule`** in your **`app.module.ts`** file:

```tsx
import { Module } from "@nestjs/common";
import { ConfigModule } from "@nestjs/config";
import { FacteurService } from "./facteur.service";

@Module({
  imports: [ConfigModule.forRoot()],
  providers: [FacteurService],
})
export class AppModule {}
```

## **Step 3: Installing Facteur Node.js SDK**

Install the Facteur Node.js SDK to our NestJS project with the following command:

```bash
npm install facteur-node
```

## **Step 4: Setting Up Facteur In NestJS**

Next, we'll create a **`FacteurService`** to encapsulate our email sending functionality:

```bash
nest generate service facteur
```

This generates a service file named **`facteur.service.ts`**. Open this file and make it look like this:

```tsx
import { Injectable } from "@nestjs/common";
import { ConfigService } from "@nestjs/config";
import Facteur, { FacteurSendEmailPayload } from "facteur-node";

@Injectable()
export class FacteurService {
  private facteur: Facteur;

  constructor(private configService: ConfigService) {
    this.facteur = new Facteur(this.configService.get("FACTEUR_API_KEY"));
  }

  async sendEmail(emailData: FacteurSendEmailPayload) {
    await this.facteur.sendEmail(emailData);
  }
}
```

Here, we inject the **`ConfigService`** to read the API key from our environment variable, then we use this key to initialize our Facteur instance.

## **Step 5: Using the FacteurService**

Now, let's create a more practical endpoint to showcase our **`FacteurService`** in action. We'll create a **`POST /signup`** route that accepts user information, and after signup, sends a confirmation email:

```tsx
import { Controller, Post, Body } from "@nestjs/common";
import { FacteurService } from "./facteur.service";

@Controller()
export class AppController {
  constructor(private readonly facteurService: FacteurService) {}

  @Post("signup")
  async signUp(@Body() userDto) {
    // Sign up the user
    // ...

    // Send a confirmation email
    await this.facteurService.sendEmail({
      from: "no-reply@example.com",
      to: userDto.email,
      subject: "Welcome to Our Service!",
      text: `Hello ${userDto.name}, Welcome to our service...`,
      html: `<p>Hello <b>${userDto.name}</b>, Welcome to our service...</p>`,
    });

    return "User created and email sent!";
  }
}
```

In the above controller, we accept user data in the request body. After signing up the user (business logic not included for brevity), we send a confirmation email using our **`FacteurService`**.

And there you have it! You've successfully set up email sending in your NestJS application using the [Facteur](https://www.facteur.dev) Node.js SDK. The usage of environment variables increases the security and scalability of your application. Happy emailing!


In this article, we will send emails with NestJS and Facteur.dev.

Sending Emails with NestJS and Facteur.dev


## Introduction

MinIO is an open source object storage server that is compatible with Amazon S3 cloud storage service. Using it in your NestJS API will allow you to store your files in it.

## Requirements

- [Node.js](https://nodejs.org/en/download/)
- [NestJS CLI](https://docs.nestjs.com/cli/overview)
- [Docker](https://docs.docker.com/get-docker/)
- [Docker Compose](https://docs.docker.com/compose/install/)

## Installation

### Create a NestJS API

First, we need to create a NestJS API. To do so, we will use the NestJS CLI.

```bash
nest new <project-name>
```

## Install the dependencies

To use MinIO in our NestJS API, we will use the MinIO client.

```bash
npm i minio && npm i -D @types/minio
```

We will also need to install the type definitions for Multer, which is a middleware for handling multipart/form-data.

```bash
npm i -D @types/multer
```

### Install MinIO

To install MinIO, we will use Docker Compose.

```bash
touch docker-compose.yml
```

Fill your `docker-compose.yml` file with the following content:

```yaml
version: "3.8"

services:
  minio:
    image: docker.io/bitnami/minio:2022
    environment:
      MINIO_ROOT_USER: minio
      MINIO_ROOT_PASSWORD: supersecret
    ports:
      - "9000:9000"
      - "9001:9001"
    volumes:
      - "minio_data:/data"

volumes:
  minio_data:
    driver: local
```

Then, type the following command to start MinIO:

```bash
docker-compose up -d
```

You are now able to access the MinIO dashboard at [http://127.0.0.1:9001](http://127.0.0.1:9001).

### Set up the NestJS Config module

To use MinIO in our NestJS API, we will use the NestJS Config module.

```bash
npm i @nestjs/config
```

Then, we will create a .env file in the root of our project.

```bash
touch .env
```

Fill your `.env` file with the following content, and make sure to replace the keys with your own :

```bash
MINIO_ENDPOINT='localhost'
MINIO_PORT=9000

MINIO_ACCESS_KEY=<my_access_key>
MINIO_SECRET_KEY=<my_secret_key>
MINIO_USE_SSL=false
MINIO_BUCKET_NAME=<my_bucket_name>
```

After doing that, we will import the ConfigModule in our `app.module.ts` file.

```typescript
import { Module } from "@nestjs/common";

import { ConfigModule } from "@nestjs/config";

@Module({
  imports: [
    ConfigModule.forRoot({
      isGlobal: true,
    }),
  ],
})
export class AppModule {}
```

## Usage

### Create a MinIO service

To use MinIO in our NestJS API, we will create a MinIO service.

```bash
nest g service minio
```

Fill your `minio.service.ts` file with the following content:

```typescript
import { Injectable } from "@nestjs/common";
import * as Minio from "minio";

@Injectable()
class MinioService {
  private minioClient: Minio.Client;
  private bucketName: string;

  constructor(private readonly configService: ConfigService) {
    this.minioClient = new Minio.Client({
      endPoint: this.configService.get("MINIO_ENDPOINT"),
      port: Number(this.configService.get("MINIO_PORT")),
      useSSL: this.configService.get("MINIO_USE_SSL") === "true",
      accessKey: this.configService.get("MINIO_ACCESS_KEY"),
      secretKey: this.configService.get("MINIO_SECRET_KEY"),
    });
    this.bucketName = this.configService.get("MINIO_BUCKET_NAME");
  }

  async createBucketIfNotExists() {
    const bucketExists = await this.minioClient.bucketExists(this.bucketName);
    if (!bucketExists) {
      await this.minioClient.makeBucket(this.bucketName, "eu-west-1");
    }
  }

  async uploadFile(file: Express.Multer.File) {
    const fileName = `${Date.now()}-${file.originalname}`;
    await this.minioClient.putObject(
      this.bucketName,
      fileName,
      file.buffer,
      file.size
    );
    return fileName;
  }

  async getFileUrl(fileName: string) {
    return await this.minioClient.presignedUrl(
      "GET",
      this.bucketName,
      fileName
    );
  }

  async deleteFile(fileName: string) {
    await this.minioClient.removeObject(this.bucketName, fileName);
  }
}
```

Feel free to extend this service to suit your needs.

### Example

To use our MinIO service, we will fill our `app.controller.ts` file, in order to handle file uploads and downloads of book covers.

```typescript
// app.controller.ts
import {
  Controller,
  Get,
  Post,
  Param,
  Delete,
  UploadedFile,
  UseInterceptors,
} from "@nestjs/common";

@Controller()
class AppController {
  constructor(private readonly minioService: MinioService) {}

  @Post("covers")
  @UseInterceptors(FileInterceptor("file"))
  async uploadBookCover(@UploadedFile() file: Express.Multer.File) {
    await this.minioService.createBucketIfNotExists();
    const fileName = await this.minioService.uploadFile(file);
    return fileName;
  }

  @Get("covers/:fileName")
  async getBookCover(@Param("fileName") fileName: string) {
    const fileUrl = await this.minioService.getFileUrl(fileName);
    return fileUrl;
  }

  @Delete("covers/:fileName")
  async deleteBookCover(@Param("fileName") fileName: string) {
    await this.minioService.deleteFile(fileName);
    return fileName;
  }
}
```

## Conclusion

You are now able to use MinIO in your NestJS API and store your files in it.

If you have any questions, feel free to reach me.

If you liked this article, follow me on Twitter [@alexisbcz](https://twitter.com/alexisbcz) for more content like this.


In this article, we will setup MinIO inside of a NestJS REST API, in order to handle file uploads.

Handle file uploads in NestJS with MinIO


## Introduction

This guide is based on my experience deploying [AdonisJobs](https://adonisjobs.dev) to production on Fly.io. Fly.io is a great platform for deploying Docker images. It's easy to setup and has a useful dashboard for managing your application.

## Prerequisites

Before you begin, you should have the following:

- a Fly.io account, if you don't have one, you can sign up for free [here](https://fly.io/signup) ;
- a working AdonisJS application.

## Install the Fly CLI

The Fly CLI is a command-line tool that allows you to deploy your application to Fly.io. You can install it by running the following command:

```bash
curl -L https://fly.io/install.sh | sh
```

## Login to Fly

After installing the Fly CLI, you can login to Fly by running the following command:

```bash
fly auth login
```

## Dockerize your application

Fly.io deploys your application as a Docker container. So, you need to create a Dockerfile for your application. You can create a Dockerfile by running the following command:

```bash
touch Dockerfile .dockerignore
```

Then, add the following content to the Dockerfile:

```text
ARG NODE_IMAGE=node:16.13.1-alpine

FROM $NODE_IMAGE AS base
RUN apk --no-cache add dumb-init g++ make py3-pip
RUN mkdir -p /home/node/app && chown node:node /home/node/app
WORKDIR /home/node/app
USER node
RUN mkdir tmp

FROM base AS dependencies
COPY --chown=node:node ./package*.json ./
RUN npm ci
COPY --chown=node:node . .

FROM dependencies AS build
RUN node ace build --production

FROM base AS production
ENV NODE_ENV=production
ENV PORT=$PORT
ENV HOST=0.0.0.0
COPY --chown=node:node ./package*.json ./
RUN npm ci --production
COPY --chown=node:node --from=build /home/node/app/build .
EXPOSE $PORT
CMD [ "dumb-init", "node", "server.js" ]
```

```bash
# Adonis default .gitignore ignores
node_modules
build
coverage
.vscode
.DS_STORE
.env
tmp

# Additional .gitignore ignores (any custom file you wish)
.idea

# Additional good to have ignores for dockerignore
Dockerfile*
docker-compose*
.dockerignore
*.md
.git
.gitignore
```

## Create a Fly application

After creating a Dockerfile, you can create a Fly application by running the following command:

```bash
fly apps create <app-name>
```

## Set up your database

Fly.io uses PostgreSQL as the default database. You can create a PostgreSQL database by running the following command:

```bash
fly databases create <db-name>
```

## Set up your environment variables

Fly.io uses secrets to configure your application. You can set up your environment variables by running the following command:

```bash
fly secrets set PORT=3333 NODE_ENV=production APP_KEY=<app-key> DB_CONNECTION=pg DB_HOST=<db-host> DB_PORT=<db-port> DB_USER=<db-user> DB_PASSWORD=<db-password> DB_DATABASE=<db-name>
```

## Deploy your application

After setting up your environment variables, you can deploy your application by running the following command:

```bash
fly deploy
```

## Run migrations

```bash
fly ssh console -C "node ace /home/node/app/build/ace migration:run"
```

## Launch your application

After deploying your application, you can launch it by running the following command:

```bash
fly launch
```

## Conclusion

In this guide, you learned how to deploy an AdonisJS application to Fly.io.

If you have any questions, feel free to reach me.

Don't forget to follow me on Twitter [@alexisbcz](https://twitter.com/alexisbcz) for more content like this.


In this article, we'll deploy an AdonisJS application to Fly.io.