In.Orbit Back-End

Esse é o lado do servidor do projeto in.orbit, ele é uma API construída junto ao Drizzle ORM para ser requisitada pelo Front-End e assim levar os dados até o lado do cliente...

O projeto foi criado no evento NLW da RocketSeat com nível intermediário com tutoria do Diego Fernandes.

Drizzle ORM

Foi a primeira vez que trabalhei com esse ORM, já tinha tido experiências anteriores com o Prisma Schema então já tinha certa familiariadade com o uso de ORMs, mas ainda si foi uma experiência muito agregadora...

Como usar?

Instalação

npm i drizzle-orm & npm i drizzle-kit & npm i postgres

Obs: Baixei o 'postgres' pois foi o banco que usei

Iniciando Schema

src/bd/index.ts

import { drizzle } from 'drizzle-orm/postgres-js'
import postgres from 'postgres'
import * as schema from './schema'
import { env } from '../env'

export const client = postgres(env.DATABASE_URL)
export const db = drizzle(client, { schema })

Com esse trecho acima declarado já é possível manipular o banco de dados

Declarando tabelas

src/bd/schema.ts

import { pgTable, text, integer, timestamp } from 'drizzle-orm/pg-core'
import { createId } from '@paralleldrive/cuid2'

export const goals = pgTable('goals', {
  id: text('id')
    .primaryKey()
    .$defaultFn(() => createId()),
  title: text('title').notNull(),
  desiredWeeklyFrequency: integer('desired_weekly_frequency').notNull(),
  createdAt: timestamp('created_at', { withTimezone: true })
    .notNull()
    .defaultNow(),
})

export const goalCompletions = pgTable('goal_completions', {
  id: text('id')
    .primaryKey()
    .$defaultFn(() => createId()),
  goalId: text('goal_id')
    .references(() => goals.id, { onDelete: 'cascade' })
    .notNull(),
  createdAt: timestamp('created_at', { withTimezone: true })
    .notNull()
    .defaultNow(),
})

Executando drizzle-kit

Criando "molde" para upar para o banco

npx drizzle-kit generate

Upando molde das tabelas para o banco

npx drizzle-kit migrate

Finalizando

Com isso já temos nosso banco de dados criado e estabelicida a conexão com o ORM.

Construindo a API

Nesse caso utilizei o Fastify para construção de rotas(primeira vez que fiz isso, anteriormente utilizava o Express)

Instalação

npm i fastify & npm i fastify-type-provider-zod & npm i @fastify/cors

Começando

src/http/server.ts

import fastify from 'fastify'
import {
  serializerCompiler,
  validatorCompiler,
  type ZodTypeProvider,
} from 'fastify-type-provider-zod'
import fastifyCors from '@fastify/cors'

const app = fastify().withTypeProvider<ZodTypeProvider>()

app.register(fastifyCors, {
  origin: '*',
})

app.setValidatorCompiler(validatorCompiler)
app.setSerializerCompiler(serializerCompiler)

app
  .listen({
    port: Number(env.PORT),
  })
  .then(() => {
    console.log(`HTTP server running! PORT:${env.PORT}`)
  })

Declarando rotas

Deixarei abaixo um exemplo de como criei uma rota e posteriormente adicionei ao fastify.

Função criada para possibilitar a criação das rotas

src/functions/create-goals.ts

import { db } from '../db'
import { goals } from '../db/schema'

interface CreateGoalRequest {
  title: string
  desiredWeeklyFrequency: number
}

export async function createGoal({
  title,
  desiredWeeklyFrequency,
}: CreateGoalRequest) {
  const result = await db
    .insert(goals)
    .values({
      title,
      desiredWeeklyFrequency,
    })
    .returning()

  const goal = result[0]

  return {
    goal,
  }
}

Aplicação da função na rota

src/http/create-goal.ts

import { z } from 'zod'
import type { FastifyPluginAsyncZod } from 'fastify-type-provider-zod'
import { createGoal } from '../functions/create-goals'

export const createGoalRoute: FastifyPluginAsyncZod = async app => {
  app.post(
    '/goals',
    {
      schema: {
        body: z.object({
          title: z.string(),
          desiredWeeklyFrequency: z.number().int().min(1).max(7),
        }),
      },
    },
    async req => {
      const { title, desiredWeeklyFrequency } = req.body
      await createGoal({
        title: title,
        desiredWeeklyFrequency: desiredWeeklyFrequency,
      })
    }
  )
}

Agora basta voltar lá na tela inicial e "registrar" a rota

src/http/server.ts

import fastify from 'fastify'
import {
  serializerCompiler,
  validatorCompiler,
  type ZodTypeProvider,
} from 'fastify-type-provider-zod'
import fastifyCors from '@fastify/cors'
import { createGoalRoute } from '../http/create-goal'

const app = fastify().withTypeProvider<ZodTypeProvider>()

app.register(fastifyCors, {
  origin: '*',
})

app.setValidatorCompiler(validatorCompiler)
app.setSerializerCompiler(serializerCompiler)

// Trecho em que é registrado 
app.register(createGoalRoute)

app
  .listen({
    port: Number(env.PORT),
  })
  .then(() => {
    console.log(`HTTP server running! PORT:${env.PORT}`)
  })

Finalizando

Com isso já é possível entender o molde da aplicação, claro existem outras rotas (aproximadamente 5) e funções, mas a base dessa aplicação é essa

Consultando servidor

Para realizar as consultas utilizo há bastante tempo o Insomnia.

Conheço também o Postman, funciona perfeitamente bem, porém não é minha preferência kkk

Exemplo de uso

Autores

• @Victor-Lis
• @Diego Fernandes