@laboratory-one/api-components 0.0.1 → 0.0.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@laboratory-one/api-components",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "API components for Laboratory One",
   "author": "Laboratory One",
   "private": false,
@@ -8,7 +8,7 @@
   "main": "./dist/cjs/index.js",
   "module": "./dist/esm/index.js",
   "types": "./dist/esm/index.d.ts",
-  "type": "module",
+  "type": "commonjs",
   "publishConfig": {
     "access": "public",
     "registry": "https://registry.npmjs.org/"
@@ -23,6 +23,7 @@
     "build": "yarn build:esm && yarn build:cjs",
     "build:esm": "tsc",
     "build:cjs": "tsc --module commonjs --outDir dist/cjs",
+    "generate": "prisma generate",
     "publish": "npm publish --access public",
     "publish:local": "yalc publish",
     "push:local": "yalc push",
@@ -85,5 +86,9 @@
     "prettier": "3.3.2",
     "tsconfig-paths": "4.2.0",
     "tsc-alias": "1.8.8"
-  }
+  },
+  "files": [
+    "dist",
+    "src"
+  ]
 }

package/src/auth/auth.module.ts

@@ -0,0 +1,10 @@
+import { Module } from '@nestjs/common';
+import { AuthService } from './auth.service';
+import { ConfigModule } from '@nestjs/config';
+
+@Module({
+  imports: [ConfigModule],
+  providers: [AuthService],
+  exports: [AuthService],
+})
+export class AuthModule {}

package/src/auth/auth.service.ts

@@ -0,0 +1,38 @@
+import { Injectable, Logger } from '@nestjs/common';
+import * as stytch from 'stytch';
+import { ConfigService } from '@nestjs/config';
+
+import { RegisterRequestDto } from '../user/dtos/register.request.dto';
+
+@Injectable()
+export class AuthService {
+  private readonly logger: Logger = new Logger(AuthService.name);
+  private authClient: stytch.Client;
+
+  constructor(private configService: ConfigService) {
+    this.authClient = new stytch.Client({
+      project_id: this.configService.get<string>('STYTCH_PROJECT_ID'),
+      secret: this.configService.get<string>('STYTCH_SECRET'),
+      env:
+        this.configService.get<string>('STYTCH_ENV') === 'test'
+          ? stytch.envs.test
+          : stytch.envs.live,
+    });
+  }
+
+  async signup(data: RegisterRequestDto): Promise<boolean> {
+    this.logger.debug('signup');
+
+    const res = await this.authClient.passwords.create(data);
+
+    return res['status_code'] === 200;
+  }
+
+  async login(data: RegisterRequestDto): Promise<boolean> {
+    this.logger.debug('login');
+
+    const res = await this.authClient.passwords.authenticate(data);
+
+    return res['status_code'] === 200;
+  }
+}

package/src/auth/index.ts

@@ -0,0 +1,2 @@
+export * from './auth.module';
+export * from './auth.service';

package/src/enums/humanDay.enum.ts

@@ -0,0 +1,9 @@
+export enum EHumanDay {
+  MONDAY = 'Monday',
+  TUESDAY = 'Tuesday',
+  WEDNESDAY = 'Wednesday',
+  THURSDAY = 'Thursday',
+  FRIDAY = 'Friday',
+  SATURDAY = 'Saturday',
+  SUNDAY = 'Sunday',
+}

package/src/enums/index.ts

@@ -0,0 +1,2 @@
+export * from './humanDay.enum';
+export * from './serverDay.enum';

package/src/enums/serverDay.enum.ts

@@ -0,0 +1,9 @@
+export enum EServerDay {
+  MONDAY = 0,
+  TUESDAY = 1,
+  WEDNESDAY = 2,
+  THURSDAY = 3,
+  FRIDAY = 4,
+  SATURDAY = 5,
+  SUNDAY = 6,
+}

package/src/guard/auth.guard.ts

@@ -0,0 +1,46 @@
+import {
+  CanActivate,
+  ExecutionContext,
+  Injectable,
+  UnauthorizedException,
+} from '@nestjs/common';
+import { JwtService } from '@nestjs/jwt';
+import { Request } from 'express';
+import { ConfigService } from '@nestjs/config';
+
+@Injectable()
+export class AuthGuard implements CanActivate {
+  constructor(
+    private jwtService: JwtService,
+    private configService: ConfigService,
+  ) {}
+
+  async canActivate(context: ExecutionContext): Promise<boolean> {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    const request = context.switchToHttp().getRequest();
+    const token = this.extractTokenFromHeader(request);
+
+    if (!token) {
+      throw new UnauthorizedException();
+    }
+
+    try {
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+      const payload = await this.jwtService.verifyAsync(token, {
+        secret: this.configService.get<string>('JWT_SECRET'),
+      });
+
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+      request['user'] = payload;
+    } catch {
+      throw new UnauthorizedException();
+    }
+
+    return true;
+  }
+
+  private extractTokenFromHeader(request: Request): string | undefined {
+    const [type, token] = request.headers.authorization?.split(' ') ?? [];
+    return type === 'Bearer' ? token : undefined;
+  }
+}

package/src/guard/index.ts

@@ -0,0 +1 @@
+export * from './auth.guard';

package/src/health/dtos/health.response.dto.ts

@@ -0,0 +1,25 @@
+import {
+  HealthCheckResult,
+  HealthCheckStatus,
+} from '@nestjs/terminus/dist/health-check/health-check-result.interface';
+import { IsString } from 'class-validator';
+import { ApiProperty } from '@nestjs/swagger';
+import { HealthIndicatorResult } from '@nestjs/terminus/dist/health-indicator';
+
+export class HealthResponseDto implements HealthCheckResult {
+  @ApiProperty()
+  status: HealthCheckStatus;
+
+  @ApiProperty()
+  info?: HealthIndicatorResult;
+
+  @ApiProperty()
+  error?: HealthIndicatorResult;
+
+  @ApiProperty()
+  details: HealthIndicatorResult;
+
+  @IsString()
+  @ApiProperty()
+  environment: string;
+}

package/src/health/dtos/index.ts

@@ -0,0 +1 @@
+export * from './health.response.dto';

package/src/health/health.controller.ts

@@ -0,0 +1,23 @@
+import { Controller, Get } from '@nestjs/common';
+import { HealthCheck } from '@nestjs/terminus';
+import { ApiResponse, ApiTags } from '@nestjs/swagger';
+
+import { HealthService } from './health.service';
+import { HealthResponseDto } from './dtos/health.response.dto';
+
+@ApiTags('Health')
+@Controller('health')
+export class HealthController {
+  constructor(private readonly healthService: HealthService) {}
+
+  @Get()
+  @ApiResponse({
+    status: 200,
+    description: 'health check successful',
+    type: HealthResponseDto,
+  })
+  @HealthCheck()
+  async healthCheck(): Promise<HealthResponseDto> {
+    return this.healthService.check();
+  }
+}

package/src/health/health.module.ts

@@ -0,0 +1,13 @@
+import { Module } from '@nestjs/common';
+import { TerminusModule } from '@nestjs/terminus';
+import { HttpModule } from '@nestjs/axios';
+
+import { HealthController } from './health.controller';
+import { HealthService } from './health.service';
+
+@Module({
+  controllers: [HealthController],
+  imports: [TerminusModule, HttpModule],
+  providers: [HealthService],
+})
+export class HealthModule {}

package/src/health/health.service.ts

@@ -0,0 +1,43 @@
+import { Injectable, Logger } from '@nestjs/common';
+import {
+  HealthCheckService,
+  HttpHealthIndicator,
+  MemoryHealthIndicator,
+} from '@nestjs/terminus';
+import { ConfigService } from '@nestjs/config';
+import { HealthCheckResult } from '@nestjs/terminus/dist/health-check/health-check-result.interface';
+
+import { HealthResponseDto } from './dtos/health.response.dto';
+
+// this decorator indicates to nest that this class can be provided to a module
+// we want to handle logic in services to keep our resolvers and controllers clean
+@Injectable()
+export class HealthService {
+  // grab the global logger instance
+  private readonly logger: Logger = new Logger(HealthService.name);
+
+  constructor(
+    private readonly configService: ConfigService,
+    private readonly health: HealthCheckService,
+    private readonly http: HttpHealthIndicator,
+    private readonly memory: MemoryHealthIndicator,
+  ) {}
+
+  async check(): Promise<HealthResponseDto> {
+    // this logger has several logging levels
+    this.logger.log('check');
+
+    const statuses: HealthCheckResult = await this.health.check([
+      async () => this.http.pingCheck('website', 'https://google.com'),
+      async () => this.memory.checkHeap('memoryHeap', 200 * 1024 * 1024),
+      async () => this.memory.checkRSS('memoryRss', 3000 * 1024 * 1024),
+    ]);
+
+    const environment: string = this.configService.get<string>('NODE_ENV');
+
+    return {
+      environment,
+      ...statuses,
+    };
+  }
+}

package/src/health/index.ts

@@ -0,0 +1,4 @@
+export * from './dtos';
+export * from './health.controller';
+export * from './health.module';
+export * from './health.service';

package/src/index.ts

@@ -1,11 +1,12 @@
-export * from './api';
-export * from './components';
-export * from './containers';
-export * from './enums';
-export * from './forms';
-export * from './hooks';
-export * from './providers';
-export * from './services';
-export * from './state';
-export * from './types';
-export * from './utils';
+export * from './auth'
+export * from './enums'
+export * from './guard'
+export * from './health'
+export * from './middleware'
+export * from './prisma'
+export * from './push'
+export * from './search'
+export * from './services'
+export * from './types'
+export * from './user'
+export * from './utils'

package/src/middleware/index.ts

@@ -0,0 +1 @@
+export * from './logger.middleware';

package/src/middleware/logger.middleware.ts

@@ -0,0 +1,24 @@
+import { Injectable, Logger, NestMiddleware } from '@nestjs/common';
+import { NextFunction, Request, Response } from 'express';
+
+@Injectable()
+export class LoggerMiddleware implements NestMiddleware {
+  private readonly logger = new Logger(LoggerMiddleware.name);
+
+  use(req: Request, _res: Response, next: NextFunction): void {
+    if (
+      req?.method === 'POST' &&
+      req?.originalUrl === '/graphql' &&
+      req?.body?.operationName
+    ) {
+      this.logger.log(
+        // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+        `${req.method} ${req.originalUrl} ${req.body.operationName}`,
+      );
+    } else {
+      this.logger.log(`${req.method} ${req.originalUrl}`);
+    }
+
+    next();
+  }
+}

package/src/prisma/index.ts

@@ -0,0 +1,2 @@
+export * from './prisma.module';
+export * from './prisma.service';

package/src/prisma/prisma.module.ts

@@ -0,0 +1,10 @@
+import { Module } from '@nestjs/common';
+
+import { PrismaService } from './prisma.service';
+
+@Module({
+  imports: [],
+  providers: [PrismaService],
+  exports: [PrismaService],
+})
+export class PrismaModule {}

package/src/prisma/prisma.service.ts

@@ -0,0 +1,36 @@
+import {
+  INestApplication,
+  Injectable,
+  Logger,
+  OnModuleInit,
+} from '@nestjs/common';
+import { Prisma, PrismaClient } from '@prisma/client';
+
+@Injectable()
+export class PrismaService extends PrismaClient implements OnModuleInit {
+  private readonly logger = new Logger(PrismaService.name);
+
+  constructor() {
+    super({ log: [{ emit: 'event', level: 'query' }] });
+
+    this.logger.log(`Prisma v${Prisma.prismaVersion.client}`);
+
+    this.$on('query' as never, (event: Prisma.QueryEvent) => {
+      this.logger.debug(
+        `[${event.duration}ms] ${event.query} ${event.params} `,
+      );
+    });
+  }
+
+  async onModuleInit() {
+    await this.$connect();
+  }
+
+  // eslint-disable-next-line @typescript-eslint/require-await
+  async enableShutdownHooks(app: INestApplication) {
+    // eslint-disable-next-line @typescript-eslint/no-misused-promises
+    this.$on('beforeExit' as never, async () => {
+      await app.close();
+    });
+  }
+}

package/src/push/index.ts

@@ -0,0 +1,2 @@
+export * from './push.module';
+export * from './push.service';

package/src/push/push.module.ts

@@ -0,0 +1,10 @@
+import { Module } from '@nestjs/common';
+
+import { PushService } from './push.service';
+
+@Module({
+  imports: [],
+  providers: [PushService],
+  exports: [PushService],
+})
+export class PushModule {}

package/src/push/push.service.ts

@@ -0,0 +1,63 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { Expo, ExpoPushMessage } from 'expo-server-sdk';
+
+@Injectable()
+export class PushService {
+  private readonly logger: Logger = new Logger(PushService.name);
+  private readonly expo: Expo | undefined;
+
+  constructor() {
+    this.expo = new Expo({
+      useFcmV1: true,
+    });
+  }
+
+  createMessages({
+    body,
+    pushTokens,
+  }: {
+    body: string;
+    pushTokens: string[];
+  }): ExpoPushMessage[] {
+    this.logger.debug('createMessage');
+
+    // Create the messages that you want to send to clients
+    const messages: ExpoPushMessage[] = [];
+
+    for (const pushToken of pushTokens) {
+      if (!Expo.isExpoPushToken(pushToken)) {
+        continue;
+      }
+
+      messages.push({
+        to: pushToken,
+        sound: 'default',
+        body,
+        data: { withSome: 'data' },
+      });
+    }
+
+    return messages;
+  }
+
+  async sendMessages(messages: ExpoPushMessage[]): Promise<undefined> {
+    try {
+      this.logger.debug('sendMessages');
+
+      const chunks: ExpoPushMessage[][] =
+        this.expo.chunkPushNotifications(messages);
+
+      for await (const chunk of chunks) {
+        try {
+          await this.expo.sendPushNotificationsAsync(chunk);
+        } catch (error) {
+          console.error(error);
+        }
+      }
+
+      return;
+    } catch (error) {
+      this.logger.error(error);
+    }
+  }
+}

package/src/search/index.ts

@@ -0,0 +1,2 @@
+export * from './search.module';
+export * from './search.service';

package/src/search/search.module.ts

@@ -0,0 +1,10 @@
+import { Module } from '@nestjs/common';
+
+import { SearchService } from './search.service';
+
+@Module({
+  imports: [],
+  providers: [SearchService],
+  exports: [SearchService],
+})
+export class SearchModule {}

package/src/search/search.service.ts

@@ -0,0 +1,86 @@
+import { Injectable, Logger } from '@nestjs/common';
+import algoliasearch from 'algoliasearch';
+import { SearchClient, SearchIndex } from 'algoliasearch/dist/algoliasearch';
+import { ConfigService } from '@nestjs/config';
+
+@Injectable()
+export class SearchService {
+  private readonly logger: Logger = new Logger(SearchService.name);
+  private readonly searchClient: SearchClient | undefined;
+  private readonly searchIndex: SearchIndex | undefined;
+
+  constructor(private configService: ConfigService) {
+    this.searchClient = algoliasearch(
+      this.configService.get('ALGOLIA_APP_ID'),
+      this.configService.get('ALGOLIA_API_KEY'),
+    );
+
+    if (this.searchClient === undefined) {
+      throw new Error('Search client is undefined');
+    }
+
+    this.searchIndex = this.searchClient.initIndex(
+      this.configService.get('ALGOLIA_INDEX_NAME'),
+    );
+  }
+
+  async shouldIndex(): Promise<boolean> {
+    this.logger.debug('shouldIndex');
+
+    if (this.searchIndex === undefined) {
+      throw new Error('Search index is undefined');
+    }
+
+    const { nbHits } = await this.searchIndex.search('', {
+      hitsPerPage: 1,
+    });
+
+    return nbHits === 0;
+  }
+
+  async create(inventoryItem: any): Promise<undefined> {
+    this.logger.debug('create');
+
+    if (this.searchIndex === undefined) {
+      throw new Error('Search index is undefined');
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    const mappedExercise = {
+      ...inventoryItem,
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+      objectID: inventoryItem.id,
+      quantity: 0,
+    };
+
+    await this.searchIndex.saveObject(mappedExercise).wait();
+
+    return;
+  }
+
+  async createMany(inventoryItems: any[]): Promise<undefined> {
+    try {
+      this.logger.debug('createMany');
+
+      if (this.searchIndex === undefined) {
+        throw new Error('Search index is undefined');
+      }
+
+      const mappedExercises = inventoryItems.map((inventoryItem: any) => {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+        return {
+          ...inventoryItem,
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+          objectID: inventoryItem.id,
+          quantity: 0,
+        };
+      });
+
+      await this.searchIndex.saveObjects(mappedExercises).wait();
+
+      return;
+    } catch (error) {
+      this.logger.error(error);
+    }
+  }
+}

package/src/services/index.ts

@@ -0,0 +1 @@
+export * from './instrument-sentry'

package/src/services/instrument-sentry.ts

@@ -0,0 +1,19 @@
+import * as Sentry from '@sentry/node';
+import { nodeProfilingIntegration } from '@sentry/profiling-node';
+
+export const initSentry = () => {
+// Ensure to call this before requiring any other modules!
+  Sentry.init({
+    dsn: process.env.SENTRY_DSN,
+    integrations: [
+      // Add our Profiling integration
+      nodeProfilingIntegration(),
+    ],
+    // Add Tracing by setting tracesSampleRate
+    // We recommend adjusting this value in production
+    tracesSampleRate: 1.0,
+    // Set sampling rate for profiling
+    // This is relative to tracesSampleRate
+    profilesSampleRate: 1.0,
+  })
+}

package/src/types/index.ts

@@ -1 +1 @@
-export * from '.';
+export * from './success.response.dto';

package/src/user/dtos/get-user.response.dto.ts

@@ -0,0 +1,32 @@
+import { IsEnum, IsOptional, IsString } from 'class-validator';
+import { ApiProperty } from '@nestjs/swagger';
+import { OnboardingStatus } from '@prisma/client';
+
+export class GetUserResponseDto {
+  @IsString()
+  @ApiProperty()
+  id: string;
+
+  @IsString()
+  @ApiProperty()
+  email: string;
+
+  @IsOptional()
+  @IsString()
+  @ApiProperty()
+  phoneNumber?: string | undefined;
+
+  @IsOptional()
+  @IsString()
+  @ApiProperty()
+  fullName?: string | undefined;
+
+  @IsOptional()
+  @IsString()
+  @ApiProperty()
+  pushToken?: string | undefined;
+
+  @IsEnum(OnboardingStatus)
+  @ApiProperty()
+  onboardingStatus: OnboardingStatus;
+}

package/src/user/dtos/index.ts

@@ -0,0 +1,5 @@
+export * from './get-user.response.dto';
+export * from './register.request.dto';
+export * from './register.response.dto';
+export * from './update-user.request.dto';
+

package/src/user/dtos/register.request.dto.ts

@@ -0,0 +1,12 @@
+import { IsString } from 'class-validator';
+import { ApiProperty } from '@nestjs/swagger';
+
+export class RegisterRequestDto {
+  @IsString()
+  @ApiProperty()
+  email: string;
+
+  @IsString()
+  @ApiProperty()
+  password: string;
+}

package/src/user/dtos/register.response.dto.ts

@@ -0,0 +1,10 @@
+import { IsString } from 'class-validator';
+import { ApiProperty } from '@nestjs/swagger';
+
+import { GetUserResponseDto } from './get-user.response.dto';
+
+export class RegisterResponseDto extends GetUserResponseDto {
+  @IsString()
+  @ApiProperty()
+  token: string;
+}