DEV Community: Filipe Braga

Benefício Fiscal com o Fator R

Filipe Braga — Thu, 17 Oct 2024 18:01:32 +0000

O "fator R" é um indicador utilizado no regime tributário do Simples Nacional para determinar a forma de tributação de algumas atividades de prestação de serviços. Ele é calculado com base na relação entre a folha de salários (incluindo encargos) dos últimos 12 meses e o faturamento bruto da empresa no mesmo período.

A fórmula para o cálculo do fator R é:

Fator R = Folha de Salários dos Últimos 12 Meses \ Faturamento Bruto dos Últimos 12 Meses

Se o fator R for igual ou superior a 28%, a empresa poderá ser tributada pelo Anexo III, que apresenta alíquotas de imposto mais baixas, começando em 6%. Caso o fator R seja inferior a 28%, a tributação ocorre pelo Anexo V, onde as alíquotas iniciais são mais altas, partindo de 15,5%.

Portanto, para obter o benefício fiscal de pagar menos impostos, é necessário que a relação entre a folha de salários e o faturamento seja de, no mínimo, 28%. Isso incentiva as empresas a aumentarem a formalização e contratação de mão de obra.

NodeJS: what do JavaScript, a V8 engine, and a dinosaur have in common?

Filipe Braga — Wed, 10 May 2023 23:47:22 +0000

Let's imagine you are building a house. To build the house, you need building materials, tools, and a plan. JavaScript, Chrome V8 engine and the Libuv are the different tools and materials we will use to do it.

javascript:

This is like the bricks blocks, cement and the blueprint we use to build the house. It is the main material or language that we use to create and control what our house will look like and how it will function.

v8 Engine:

This is the constructor builder who reads the blueprint (JavaScript) and knows exactly how to turn it into a strong and finished house. The V8 engine is a powerful worker that understands our JavaScript code and makes it run quickly and efficiently on the computer.
💡V8 is Google's open source high-performance JavaScript and WebAssembly engine, written in C++. It is used in Chrome and in Node.js, among others. It implements ...

libuv:

This is like the plumbing and electricity in our house, making sure that everything works smoothly and all the different parts of the house can communicate with each other. libuv helps with managing tasks and events in our Node.js house, so that it can handle many things at once, like turning on lights or using the faucet, without any problems.
💡libuv is a C library originally written for Node.js to abstract non-blocking I/O operations.

When we put all these elements together, we can build a strong, efficient, and functional house, which is our Node.js application. #nodejs is an open-source, cross-platform JavaScript runtime environment that allows developers to execute JavaScript code outside of a web browser.

Troubleshooting Timezone Issues in PostgreSQL with DBeaver

Filipe Braga — Fri, 24 Mar 2023 17:04:14 +0000

When working with a PostgreSQL database and querying data using a tool like DBeaver, it's not uncommon to run into issues where the time displayed in DBeaver doesn't match the time stored in the database. This can be confusing and frustrating, but fortunately, the most likely cause is easy to fix: the timezone settings in DBeaver.

PostgreSQL stores dates and times in UTC format by default. This means that if you query a timestamp field in the database, you'll get back a value in UTC time. However, when that value is displayed in DBeaver, it will be adjusted to the timezone settings of your computer, which may not be the same as the server hosting the database.

To fix this, you'll need to adjust the timezone settings in DBeaver to match the timezone of the server. You can do this by going to the "Window", and then selecting the "Preferences" tab. From there, you should see a setting for "User Interface". Set the timezone value to UTCZ, and then save your changes.

Once you've made this adjustment, your queries should return results that match the actual timestamp values stored in the database. Keep in mind, though, that this adjustment only affects DBeaver. If you're using another tool to query the database, or if you're running queries programmatically, you may need to adjust the timezone settings in those tools as well.

It's also worth noting that if you're working with a database that spans multiple timezones, you may need to take additional steps to ensure that your queries return accurate results. For example, you may need to convert timestamps to a consistent timezone before comparing them or aggregating data. However, for most cases, adjusting the timezone settings in DBeaver should be sufficient.

In conclusion, if you're seeing a discrepancy between the time displayed in DBeaver and the time stored in your PostgreSQL database, don't panic. It's likely just a timezone issue, and can be easily fixed by adjusting the serverTimezone setting in DBeaver. With a little bit of configuration, you'll be able to query your database with confidence, knowing that you're working with accurate timestamp values.

PostgreSQL #DBeaver #timezone #database #timestamp #UTC #serverTimezone #querying #data #configuration #accuracy #datetime #computing #programming

API with Typescript + Nest + TypeORM + Postgres + Docker

Filipe Braga — Tue, 21 Mar 2023 17:17:42 +0000

In this blog post, I'll show you how to set up a project using TypeScript, Nest, Postgres, Docker and how to seed your database.

TypeScript is a statically typed language that is a strict syntactical superset of JavaScript. It offers improved type safety and tooling support, making it a popular choice for larger-scale projects.

Nest is a framework for building efficient, scalable Node.js server-side applications. It provides a structure and a range of features that make it easier to develop and test applications.

Postgres is a powerful open-source relational database management system that is well suited for complex data structures and large-scale data processing.

TypeORM is an open-source Object Relational Mapping (ORM) tool that provides a way to interact with relational databases such as MySQL, PostgreSQL, and SQLite. It helps you to write database-related code using object-oriented programming in TypeScript or JavaScript, instead of writing raw SQL statements. TypeORM offers a lot of features such as transaction management, database migrations, connection pooling, etc. that makes it easy to work with databases in your applications.

Docker is a containerization platform that makes it easier to deploy and run applications in different environments. We will launch a Postgres database and supporting service in docker.

Nest:
First, install nest-cli
npm i -g @nestjs/cli

Then, create a new project using the nest cli
nest new project-name

Choose: npm for package manager,

Next, enter in the project folder
cd project-name

PostgreSQL Database
Install pg
npm install pg --save

TypeORM
Install TypeOrm
npm install --save @nestjs/typeorm typeorm postgres

Open your project with your IDE

In the app.module.ts, add the connection to the databese with TypeOrmModule.forRoot():

// app.module.ts
import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';

@Module({
  imports: [
    TypeOrmModule.forRoot({
      type: 'postgres',
      host: 'localhost',
      port: 5432,
      username: 'root',
      password: 'password',
      database: 'postgres',
      entities: [`${__dirname}/typeorm/entities/*{.js,.ts}`],
      synchronize: true, // do not use in prod
    }),
  ],
})
export class AppModule {}

BTW: you can delete app.service and app.controller

Now, we should create our first module with nest cli:
nest g resource modules/users

choose REST API on terminal
select 'yes' to generate CRUD entry points

With the module created, we should now organize our project like this:

1) create some folders called: typeorm > database / entities / seeds
2) create data-source.ts, main.seed.ts and user.seed.ts
3) move the user entity to the entity folders

/src/typeorm
├── database
│   └── data-source.ts
├── seeds
│   └── main.seed.ts
└── entities
    └── user.entity.ts *(generated by the script)*

insert the code bellow into the files:

// users.entity.ts
import { Column, CreateDateColumn, DeleteDateColumn, Entity, PrimaryGeneratedColumn, UpdateDateColumn } from 'typeorm';

@Entity('users')
export class User {
  @PrimaryGeneratedColumn()
  id: number;

  @Column()
  name: string;

  @Column()
  email: string;

  @Column()
  active: boolean;

  @Column()
  birthday: Date;

  @CreateDateColumn()
  createdAt: Date;

  @UpdateDateColumn()
  updatedAt: Date;

  @DeleteDateColumn()
  deletedAt: Date;
}

// users.service.ts
import { Injectable } from '@nestjs/common';
import { User } from 'src/typeorm/entities/user.entity';
import { DataSource } from 'typeorm';
import { CreateUserDto } from './dto/create-user.dto';
import { UpdateUserDto } from './dto/update-user.dto';

@Injectable()
export class UsersService {
  constructor(private dataSource: DataSource) {}
  private userRepository = this.dataSource.getRepository(User);

  async create(createUserDto: CreateUserDto) {
    return this.userRepository.save(createUserDto);
  }

  async findAll(): Promise<User[]> {
    return this.userRepository.find();
  }

  async findOne(id: number) {
    return this.userRepository.findOneBy({ id });
  }

  async update(id: number, updateUserDto: UpdateUserDto) {
    let user = await this.findOne(id);
    user = { ...user, ...updateUserDto };
    return await this.userRepository.save(user);
  }

  async remove(id: number) {
    const user = await this.findOne(id);
    return await this.userRepository.softRemove(user);
  }
}

// data-source.ts
import { DataSource, DataSourceOptions } from 'typeorm';

export const dataSourceOptions: DataSourceOptions = {
  type: 'postgres',
  host: 'localhost',
  port: 5432,
  username: 'root',
  password: 'password',
  database: 'postgres',
  entities: ['src/**/*.entity{.js,.ts}'],
};

export default new DataSource(dataSourceOptions);

// main.seed.ts
import { DataSource } from 'typeorm';
import { dataSourceOptions } from '../database/data-source';
import { User } from '../entities/user.entity';

const dataSource = new DataSource(dataSourceOptions);
const userRepository = dataSource.getRepository(User);

async function connect() {
  try {
    if (dataSource.isInitialized) {
      await dataSource.destroy();
    }
    await dataSource.initialize();
    console.log('Data Source has been initialized!');
  } catch (err) {
    console.error('Error during Data Source connect', err);
  }
}

async function disconnect() {
  try {
    await dataSource.destroy();

    console.log('Data Source disconnected!');
  } catch (err) {
    console.error('Error during Data Source disconnect', err);
  }
}

async function seed() {
  const UserSeed = () => [
    {
      name: 'John Doe',
      email: 'john@doe.com',
      active: true,
      birthday: '1990-01-01',
    },
    {
      name: 'Jane Doe',
      email: 'jane@doe.com',
      active: false,
      birthday: '1990-01-31',
    },
    {
      name: 'Josh Doe',
      email: 'josh@doe.com',
      active: true,
      birthday: '2020-12-31',
    },
  ];

  await userRepository.save(UserSeed());
  console.log('created seeds');
}

async function runSeed() {
  await connect();
  console.log('connected');
  await seed();
  console.log('seed done');
  await disconnect();
  console.log('disconnected');
}

runSeed();

Now, we should create our 'docker-compose.yml' file in the root folder, and then run sudo docker-compose up

! Make sure the Docker is running in your system !

version: '3.1'

services:
  db:
    image: postgres:14.2-alpine
    restart: always
    environment:
      POSTGRES_USER: "root"
      POSTGRES_PASSWORD: "password"
      POSTGRES_DB: "postgres"
    ports:
      - "5432:5432"

Some useful docker commands:
sudo docker ps to list all containers
sudo docker stop my_container_name to stop a specific container

Now, add a script to package.json

// package.json
"seed":"npx ts-node src/typeorm/seeds/main.seed.ts",

in a new terminal on the IDE run the code npm start to synchronize the database

kill the application, and then run the script npm run seed to populate the database

Its Done! now if you run npm start and send a GET request on localhost:3000/users, you shold get all the users from the seed.