@navios/core 0.2.0 → 0.2.2

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/common'
+
+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',
+    }
+  }
+}