@navios/core 0.2.1 → 0.3.0

package/README.md

@@ -23,7 +23,6 @@ It uses Fastify under the hood, which is a fast and low-overhead web framework f
 - **Service**: A service is a class that defines the business logic for a specific resource. It is used to separate the business logic from the controller and provide a clear structure for your API.
 - **Guard**: A guard is a class that is used to validate incoming requests and ensure that they meet certain criteria. Guards can be used to validate request parameters, headers, and body. They can also be used to check authentication and authorization.
 - **Attribute**: An attribute is a decorator that is used to add metadata to a class or method. Attributes can be used in guards, controllers, modules, and endpoints to provide additional information about the class or method.
- 
 
 ## Getting Started
 
@@ -33,6 +32,7 @@ Define your API in a shared location accessible to both the client and server. T
 
 ```ts
 import { builder } from '@navios/core'
+
 import { z } from 'zod'
 
 const api = builder({
@@ -66,7 +66,7 @@ const login = api.declareEndpoint({
 ### Create your server
 
 ```bash
-yarn install --save @navios/core @navios/common zod
+yarn install --save @navios/core @navios/builder zod
 ```
 
 Create AuthService:
@@ -86,7 +86,9 @@ export class LoginService {
 Create your first Controller:
 
 ```ts
-import { Controller, Endpoint, type EndpointParams, syncInject } from '@navios/core'
+import type { EndpointParams } from '@navios/core'
+
+import { Controller, Endpoint, syncInject } from '@navios/core'
 
 import { AuthService } from './auth.service.mjs'
 
@@ -111,6 +113,7 @@ export class AuthController {
   }
 }
 ```
+
 Create your AppModule:
 
 ```ts
@@ -128,6 +131,7 @@ Create your server:
 
 ```ts
 import { NaviosFactory } from '@navios/core'
+
 import { AppModule } from './src/app.module.mjs'
 
 export async function boot() {

package/docs/README.md

@@ -0,0 +1,6 @@
+# Introduction
+
+Navios us a framework for building Type-Safe Node.js servers. It uses TypeScript and Navios builder to generate a server with a specific structure. The framework is designed to be easy to use and understand, while also being powerful and flexible.
+
+Under the hood, Navios makes use of [Fastify](https://www.fastify.io/) for the server implementation, and [Zod](https://zod.dev/) for schema validation. This allows Navios to provide a type-safe experience while still being performant and easy to use.
+

package/docs/recipes/prisma.md

@@ -0,0 +1,60 @@
+# Prisma ORM
+
+Prisma ORM is a modern database toolkit that simplifies database access and management. It provides a type-safe query builder, migrations, and an intuitive API for working with databases.
+
+## Installation
+
+Follow the steps from the [Prisma documentation](https://www.prisma.io/docs/getting-started/quickstart-typescript) to install Prisma in your project.
+
+## Integration
+
+The simplest way to integrate Prisma with your project is to create a factory:
+
+```typescript
+import { Injectable, InjectableType, InjectionToken } from '@navios/core'
+
+import { PrismaClient } from '@prisma/client'
+
+export const PrismaService = InjectionToken.create(PrismaClient)
+
+@Injectable({
+  token: PrismaService,
+  type: InjectableType.Factory,
+})
+export class PrismaServiceFactory {
+  async create() {
+    const client = new PrismaClient()
+    await client.$connect()
+    return client
+  }
+}
+```
+
+## Usage
+
+You can use the Prisma Service in your application by injecting it into your classes. Here's an example of how to use it in a service:
+
+```typescript
+import { Injectable, syncInject } from '@navios/core'
+
+import { PrismaService } from './prisma.service.mjs'
+
+@Injectable()
+export class UserService {
+  private readonly prisma = syncInject(PrismaService)
+
+  async getUser(id: string) {
+    return this.prisma.user.findUnique({
+      where: { id },
+    })
+  }
+
+  async createUser(data: { name: string; email: string }) {
+    return this.prisma.user.create({
+      data,
+    })
+  }
+}
+```
+
+That's it! You can now use Prisma in your application to interact with your database. You can find more information about Prisma and its features in the [Prisma documentation](https://www.prisma.io/docs/).

package/examples/simple-test/api/index.mts

@@ -0,0 +1,64 @@
+import { builder } from '@navios/builder'
+
+import { z } from 'zod'
+
+export const authApi = builder({
+  useDiscriminatorResponse: true,
+})
+
+export const userEndpoint = authApi.declareEndpoint({
+  method: 'GET',
+  url: '/user',
+  responseSchema: z.object({
+    id: z.string(),
+    name: z.string(),
+    email: z.string(),
+  }),
+})
+
+export const patchUserEndpoint = authApi.declareEndpoint({
+  method: 'PATCH',
+  url: '/user',
+  requestSchema: z.object({
+    name: z.string(),
+    email: z.string(),
+  }),
+  responseSchema: z.object({
+    id: z.string(),
+    name: z.string(),
+    email: z.string(),
+  }),
+})
+
+export const discriminatorEndpoint = authApi.declareEndpoint({
+  method: 'GET',
+  url: '/discriminator',
+  responseSchema: z.discriminatedUnion('success', [
+    z.object({
+      success: z.literal(true),
+      data: z.object({
+        id: z.string(),
+        name: z.string(),
+
+        email: z.string(),
+      }),
+    }),
+    z.object({
+      success: z.literal(false),
+      error: z.object({
+        code: z.string(),
+        message: z.string(),
+      }),
+    }),
+  ]),
+})
+
+export const multipartEndpoint = authApi.declareMultipart({
+  method: 'POST',
+  url: '/multipart',
+  requestSchema: z.object({
+    files: z.array(z.instanceof(File)),
+    something: z.string(),
+  }),
+  responseSchema: z.object({}),
+})

package/examples/simple-test/config/config.service.mts

@@ -0,0 +1,14 @@
+import type { Path, PathValue } from '../../../src/index.mjs'
+
+import { provideConfig } from '../../../src/index.mjs'
+import { configureConfig } from './configuration.mjs'
+
+export type ConfigType = ReturnType<typeof configureConfig>
+export type ConfigTypePaths = Path<ConfigType>
+export type ConfigMap = {
+  [K in ConfigTypePaths]: PathValue<ConfigType, K>
+}
+
+export const ConfigService = provideConfig<ConfigMap>({
+  load: configureConfig,
+})

package/examples/simple-test/config/configuration.mts

@@ -0,0 +1,7 @@
+import { envInt } from '../../../src/index.mjs'
+
+export function configureConfig() {
+  return {
+    port: envInt('PORT', 4250),
+  }
+}

package/examples/simple-test/index.mts

@@ -0,0 +1,16 @@
+import { inject, NaviosFactory } from '../../src/index.mjs'
+import { ConfigService } from './config/config.service.mjs'
+import { AppModule } from './src/app.module.mjs'
+
+export async function boot() {
+  const app = await NaviosFactory.create(AppModule)
+  app.enableCors({
+    methods: ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'OPTIONS'],
+  })
+  app.enableMultipart({})
+  await app.init()
+  const configService = await inject(ConfigService)
+  const port = configService.getOrThrow('port')
+  await app.listen({ port: port, host: '0.0.0.0' })
+}
+await boot()

package/examples/simple-test/src/acl/acl-modern.guard.mts

@@ -0,0 +1,15 @@
+import type { CanActivate, ExecutionContext } from '../../../../src/index.mjs'
+
+import { Injectable, Logger, syncInject } from '../../../../src/index.mjs'
+
+@Injectable()
+export class AclModernGuard implements CanActivate {
+  logger = syncInject(Logger, {
+    context: AclModernGuard.name,
+  })
+
+  canActivate(executionContext: ExecutionContext): Promise<boolean> | boolean {
+    this.logger.log('ACL Modern Guard activated')
+    return true
+  }
+}

package/examples/simple-test/src/acl/acl.guard.mts

@@ -0,0 +1,14 @@
+import type { CanActivate, ExecutionContext } from '../../../../src/index.mjs'
+
+import { Injectable, Logger, syncInject } from '../../../../src/index.mjs'
+
+@Injectable()
+export class AclGuard implements CanActivate {
+  logger = syncInject(Logger, {
+    context: AclGuard.name,
+  })
+  canActivate(executionContext: ExecutionContext): Promise<boolean> | boolean {
+    this.logger.log('ACL Guard activated')
+    return true
+  }
+}

package/examples/simple-test/src/acl/app.guard.mts

@@ -0,0 +1,27 @@
+import type { CanActivate, ExecutionContext } from '../../../../src/index.mjs'
+
+import {
+  AttributeFactory,
+  Injectable,
+  Logger,
+  syncInject,
+} from '../../../../src/index.mjs'
+import { Public } from './public.attribute.mjs'
+
+@Injectable()
+export class AppGuard implements CanActivate {
+  logger = syncInject(Logger, {
+    context: AppGuard.name,
+  })
+
+  canActivate(executionContext: ExecutionContext): Promise<boolean> | boolean {
+    const isPublic = AttributeFactory.getLast(Public, [
+      executionContext.getModule(),
+      executionContext.getController(),
+      executionContext.getHandler(),
+    ])
+    this.logger.log('App Guard activated')
+    this.logger.log('isPublic', isPublic)
+    return true
+  }
+}

package/examples/simple-test/src/acl/one-more.guard.mts

@@ -0,0 +1,15 @@
+import type { CanActivate, ExecutionContext } from '../../../../src/index.mjs'
+
+import { Injectable, Logger, syncInject } from '../../../../src/index.mjs'
+
+@Injectable()
+export class OneMoreGuard implements CanActivate {
+  logger = syncInject(Logger, {
+    context: OneMoreGuard.name,
+  })
+
+  canActivate(executionContext: ExecutionContext): Promise<boolean> | boolean {
+    this.logger.log('One More Guard activated')
+    return true
+  }
+}

package/examples/simple-test/src/acl/public.attribute.mts

@@ -0,0 +1,21 @@
+import { z } from 'zod'
+
+import { AttributeFactory } from '../../../../src/index.mjs'
+
+export const PublicSymbol = Symbol.for('Public')
+
+export const Public = AttributeFactory.createAttribute(PublicSymbol)
+export const RolesSymbol = Symbol.for('Roles')
+
+export const RolesSchema = z.object({
+  roles: z.array(
+    z.union([
+      z.literal('VIEWER'),
+      z.literal('USER'),
+      z.literal('ADMIN'),
+      z.literal('OWNER'),
+    ]),
+  ),
+})
+
+export const Roles = AttributeFactory.createAttribute(RolesSymbol, RolesSchema)

package/examples/simple-test/src/app.module.mts

@@ -0,0 +1,9 @@
+import { Module } from '../../../src/index.mjs'
+import { AppGuard } from './acl/app.guard.mjs'
+import { UserModule } from './user/user.module.mjs'
+
+@Module({
+  imports: [UserModule],
+  guards: [AppGuard],
+})
+export class AppModule {}

package/examples/simple-test/src/user/user.controller.mts

@@ -0,0 +1,72 @@
+import type {
+  EndpointParams,
+  EndpointResult,
+  MultipartParams,
+} from '../../../../src/index.mjs'
+
+import {
+  Controller,
+  Endpoint,
+  Logger,
+  Multipart,
+  syncInject,
+  UseGuards,
+} from '../../../../src/index.mjs'
+import {
+  discriminatorEndpoint,
+  multipartEndpoint,
+  patchUserEndpoint,
+  userEndpoint,
+} from '../../api/index.mjs'
+import { AclGuard } from '../acl/acl.guard.mjs'
+import { OneMoreGuard } from '../acl/one-more.guard.mjs'
+import { Public } from '../acl/public.attribute.mjs'
+import { UserService } from './user.service.mjs'
+
+@UseGuards(AclGuard)
+@Controller()
+export class UserController {
+  userService = syncInject(UserService)
+  logger = syncInject(Logger, {
+    context: UserController.name,
+  })
+
+  @Public()
+  @UseGuards(OneMoreGuard)
+  @Endpoint(userEndpoint)
+  async me(params: EndpointParams<typeof userEndpoint>) {
+    this.logger.log(params)
+    return this.userService.getUser()
+  }
+
+  @Endpoint(patchUserEndpoint)
+  async patchMe(params: EndpointParams<typeof patchUserEndpoint>) {
+    this.logger.log(params)
+    return {
+      ...this.userService.getUser(),
+      ...params.data,
+    }
+  }
+
+  @Endpoint(discriminatorEndpoint)
+  async discriminator(
+    params: EndpointParams<typeof discriminatorEndpoint>,
+  ): EndpointResult<typeof discriminatorEndpoint> {
+    this.logger.log(params)
+    return {
+      success: true,
+      data: {
+        id: '123',
+        name: 'John Doe',
+        email: 'test@example.com',
+      },
+    }
+  }
+
+  @Multipart(multipartEndpoint)
+  async multipart(params: MultipartParams<typeof multipartEndpoint>) {
+    this.logger.log(params)
+    // params.data.
+    return {}
+  }
+}

package/examples/simple-test/src/user/user.module.mts

@@ -0,0 +1,14 @@
+import { Logger, Module, syncInject } from '../../../../src/index.mjs'
+import { AclModernGuard } from '../acl/acl-modern.guard.mjs'
+import { UserController } from './user.controller.mjs'
+
+@Module({
+  controllers: [UserController],
+  guards: [AclModernGuard],
+})
+export class UserModule {
+  logger = syncInject(Logger)
+  onModuleInit() {
+    this.logger.debug('Inside UserModule.onModuleInit')
+  }
+}

package/examples/simple-test/src/user/user.service.mts

@@ -0,0 +1,14 @@
+import { randomUUID } from 'node:crypto'
+
+import { Injectable } from '../../../../src/index.mjs'
+
+@Injectable()
+export class UserService {
+  getUser() {
+    return {
+      id: randomUUID() as string,
+      name: 'John Doe',
+      email: 'test@example.com',
+    }
+  }
+}