higher: A TypeScript repository from woen4

Higher is a framework it was built thinking in some requirements

The minimum of code lines to create an endpoint
Files with a unique responsibilty, representing a unique endpoint
Easy to test
Performance
Good developer experience
And that it works well in a serverless environment

has support to:

🔄 Middlewares (per folder level)
✅ Body and query params validation (using Zod)
⤵ Dependency injection (Test is very easy)

and was built-in using:

Fastify
Zod
Typescript
Tsup (Dev server and build process is very fast)

How to install:

  npx create-higher-app

Initial guide:

Higher follow a well defined structure, let's start with a route to retrieve users

📁 src
  📁 modules
    📁 users
      📄 get.ts
    📄 index.ts

get.ts :

  export handle = () => {
    return ["Kaio", "Woen"]
  }

index.ts :

  import { bootstrap } from "@woen4/higher";

  const server = bootstrap();

  server.listen(3000)

On run dev script, this will run your server exposing a route /users of method GET

now let's say you need to use something to access your database in that function,

so you need create a folder providers in src directory and exports a object from there

📁 src
  📁 modules
    📁 users
      📄 get.ts
  📁 providers
      📄 index.ts
      📄 prisma.ts

prisma.ts :

  import { PrismaClient } from '@prisma/client'

  export const prisma = new PrismaClient()

index.ts :

  export type Providers = typeof import("./index");

  export * from './prisma'

And then, use this in your route handler

get.ts :

  import { Providers } from '../../providers'

  export handle = (ctx: Providers) => {
    return ctx.prisma.users.findMany()
  }

But... how to acess request in handler? Simple
modules/users/post.ts

  import { Providers } from '../../providers'

  export handle = (ctx: Providers, { body }: HigherRequest) => {
    return ctx.prisma.users.create({ data: body })
  }

But... how to validate the body data? Also is simple

  import { Providers } from '../../providers'
  import { z } from "zod";

  export const schema = z.object({
    name: z.string(),
    email: z.string(),
  });

  export handle = (ctx: Providers, { body }: HigherRequest<void, typeof schema>) => {
    return ctx.prisma.users.create({ data: body })
  }

The generic type <void, typeof schema> will offer the intellisense in your editor when using body object

Ok, but I need of a middleware to authenticate my routes, how do it?. Also is very simple

Create a file named middleware.ts inside the modules folder and it will be apply to all routes, otherwise if you put your middleware file inside the users folder, it will only apply to users routes

📁 src
  📁 modules
    📄 middleware.ts
    📁 users
      📄 get.ts
      📄 get.ts
  📁 providers
      📄 index.ts
      📄 prisma.ts

middleware.ts

  import { HigherRequest, HigherResponse } from "@woen4/higher";
  import { Providers } from '../providers'

  export type WithAuth = {
    user: {
      id: string;
    };
  };

  export const handle = (ctx: Providers, request: HigherRequest<WithAuth>) => {
    /* 
    
    Some lines of code to implementate authorization

    */

    request.user = {
      id: '123',
    }
  };

One more question, how to create routes with parameters? Simple and plain

📁 src
  📁 modules
    📄 middleware.ts
    📁 users
      📄 get.ts
      📄 get.ts
      📁 [userId]
        📄 get.ts
  📁 providers
      📄 index.ts
      📄 prisma.ts

[userId]/get.ts

  import { Providers } from '../../providers'
  import { WithAuth } from '../../../middleware.ts'

  export handle = (ctx: Providers, { user }: HigherRequest<WithAuth>) => {
    
    return ctx.prisma.users.findFirst({ where: { id: user.id } })
  }

Full documention:

is coming...