@pcg/core 1.0.0-alpha.0 → 1.0.0-alpha.2

package/src/exceptions/http-exceptions.filter.ts

@@ -1,95 +0,0 @@
-import {
-    ArgumentsHost, Catch, HttpException, HttpServer,
-} from '@nestjs/common';
-import { isObject } from '@nestjs/common/utils/shared.utils';
-import { GqlArgumentsHost } from '@nestjs/graphql/dist/services/gql-arguments-host';
-
-import { AppEnv } from '#/enums/app-env.enum';
-import {
-    Logger, LoggerContext, LoggerFactory,
-} from '#/logger';
-import { HttpExceptionResponse } from './http-exception-response.js';
-
-type ContextType = 'http' | 'ws' | 'rpc' | 'graphql';
-
-/**
- * Http exception filter for NestJS
- * It is used to correctly log all http exceptions
- * @deprecated use NestErrorFilter instead
- * @see NestErrorFilter
- * @example
- * ```ts
- * // main.ts
- * const { httpAdapter } = app.get(HttpAdapterHost);
- * const loggerFactory = app.get(WINSTON_MODULE_FACTORY_PROVIDER);
- * app.useGlobalFilters(new HttpExceptionFilter(httpAdapter, loggerFactory));
- * ```
- */
-@Catch(HttpException)
-export class HttpExceptionFilter {
-  private readonly logger: Logger;
-
-  constructor(
-    protected readonly applicationRef: HttpServer,
-    private readonly loggerFactory: LoggerFactory,
-  ) {
-    this.logger = this.loggerFactory.create({
-      scope: HttpExceptionFilter.name,
-    });
-  }
-
-  catch(exception: HttpException, host: ArgumentsHost) {
-    const gqlHost = GqlArgumentsHost.create(host);
-    const type = gqlHost.getType<ContextType>();
-
-    const response = exception.getResponse() as HttpExceptionResponse;
-    if (!response?.silent) {
-      if (isObject(response)) {
-        const logger = this.loggerFactory.create(response.context);
-
-        if (response.error instanceof Error) {
-          logger.error(response.message, response.error);
-        } else {
-          logger.error(exception);
-        }
-      } else {
-        this.logger.error(exception);
-      }
-    }
-
-    if (type !== 'http') {
-      return exception;
-    }
-
-    /**
-     * If request is http, then we need to send response to client
-     */
-    let body: {
-      message: string;
-      key?: string;
-      stack?: string;
-      context?: LoggerContext;
-      statusCode: number;
-    };
-
-    if (isObject(response)) {
-      body = {
-        key: response.key,
-        message: response.message,
-        context: response.context,
-        statusCode: exception.getStatus(),
-      };
-
-      if (response.error instanceof Error && process.env.NODE_ENV !== AppEnv.PRODUCTION) {
-        body.stack = response.error.stack;
-      }
-    } else {
-      body = {
-        statusCode: exception.getStatus(),
-        message: response,
-      };
-    }
-
-    this.applicationRef.reply(host.getArgByIndex(1), body, exception.getStatus());
-  }
-}

package/src/index.ts

@@ -1,32 +0,0 @@
-export * from './abstracts/index.js';
-export * from './configs/index.js';
-export * from './context/index.js';
-export * from './enums/index.js';
-export * from './errors/index.js';
-export * from './logger/index.js';
-
-export * from './tools/compose.js';
-export * from './tools/convert-to-bigint.js';
-export * from './tools/create-list-meta.js';
-export * from './tools/define-statuses.js';
-export * from './tools/env.js';
-export * from './tools/fetch-total-with-query.js';
-export * from './tools/generate-entity-id.js';
-export * from './tools/is-object.js';
-export * from './tools/get-request-language.js';
-export * from './tools/postgres/locale-to-pg-collate.js';
-export * from './tools/remove-undefined-properties.js';
-export * from './tools/request-id.js';
-export * from './tools/stringify-opts.js';
-export * from './tools/wait.js';
-
-export * from './tools/typeorm/add-filter.js';
-export * from './tools/typeorm/ensure-inner-join.js';
-export * from './tools/typeorm/ensure-left-join.js';
-export * from './tools/typeorm/is-alias-already-busy.js';
-
-export * from './validation/index.js';
-
-export * from './exceptions/http-exception-response.js';
-export * from './exceptions/http-exceptions.filter.js';
-

package/src/jwt/extractors.ts

@@ -1,80 +0,0 @@
-import { Maybe } from '#/types/maybe';
-
-/**
- * The request interface
- */
-export interface IRequest {
-  query?: {
-    access_token?: string;
-  };
-  headers: {
-    authorization?: string;
-    Authorization?: string;
-  };
-}
-
-/**
- * Extract the access token from the request query
- * @param request - The request (like express request)
- * @returns The access token or undefined
- * @example
- * request.query.access_token = '123';
- * extractJwtFromQuery(request) // '123'
- */
-export const extractJwtFromQuery = (request: IRequest): Maybe<string> => {
-  if (!request?.query) {
-    return;
-  }
-
-  const { access_token: accessToken } = request.query;
-  if (accessToken) {
-    return accessToken;
-  }
-};
-
-/**
- * Extract the access token from the authorization header
- *
- * @param string - authorization header string
- * @returns the access token token or undefined
- *
- * @example
- * const str = 'Bearer 123';
- * extractJwtFromBearerString(str) // '123'
- */
-export const extractJwtFromBearerString = (string: string): Maybe<string> => {
-  const [method, value] = string.split(' ');
-
-  if (method === 'Bearer' && value) {
-    return value;
-  }
-};
-
-/**
- * Extract the access token from the authorization header
- * @param request The request (like express request)
- * @returns The access token or undefined
- * @example
- * request.headers.authorization = 'Bearer 123';
- * extractJwtFromBearerToken(request) // '123'
- */
-export const extractJwtFromBearerToken = (request: IRequest): Maybe<string> => {
-  const header = request?.headers?.authorization || request?.headers?.Authorization;
-  if (typeof header === 'string') {
-    const [method, value] = header.split(' ');
-
-    if (method === 'Bearer' && value) {
-      return value;
-    }
-  }
-};
-
-/**
- * Extract the access token from the request
- * @param request - The request (like express request)
- * @returns The access token or undefined
- */
-export const extractJwt = (request: IRequest) => {
-  return extractJwtFromQuery(request) || extractJwtFromBearerToken(request);
-};
-

package/src/jwt/types.ts

@@ -1,209 +0,0 @@
-/**
- * Supported JWT token types
- */
-export enum JwtTokenType {
-  /**
-   * Access token. This is authorization token that is used to access protected resources.
-   * Lives short time and can be refreshed by refresh token
-   */
-  ACCESS = 'access',
-
-  /**
-   * Refresh token.
-   * Lives long time and can be used to refresh access token
-   */
-  REFRESH = 'refresh',
-
-  /**
-   * Invite token.
-   * Used for user invitation
-   */
-  INVITE = 'invite',
-
-  /**
-   * Service token.
-   * Lives long time and can be used for service account
-   */
-  SERVICE = 'service',
-
-  /**
-   * Subscription token.
-   * USed for GraphQL subscriptions only. Lives long time
-   */
-  SUBSCRIPTION = 'subscription',
-}
-
-export interface BaseJwtTokenPayload {
-  /**
-   * Token type
-   */
-  sub: JwtTokenType;
-
-  /**
-   * Issuer. Service shortname that issued this token
-   * @example 'bo'
-   */
-  iss: string;
-
-  /**
-   * User ID
-   * @example 'hcu:1xgetnx5xq3'
-   */
-  uid: string;
-
-  /**
-   * Parent User ID who logged in as this user
-   * @example 'hcu:2zgetnx5x2h'
-   */
-  pid?: string;
-}
-
-/**
- * Payload to create new JWT access token
- */
-export interface JwtAccessTokenPayload extends BaseJwtTokenPayload {
-  sub: JwtTokenType.ACCESS;
-
-  /**
-   * Audience. Service shortnames that can use this token
-   */
-  aud: string[];
-}
-
-/**
- * Payload to create new JWT Subscription token
- */
-export interface JwtSubscriptionTokenPayload extends BaseJwtTokenPayload {
-  sub: JwtTokenType.SUBSCRIPTION;
-
-  /**
-   * Audience. Service shortnames that can use this token
-   */
-  aud: string[];
-}
-
-/**
- * Payload to create new JWT refresh token
- */
-export interface JwtRefreshTokenPayload extends BaseJwtTokenPayload {
-  sub: JwtTokenType.REFRESH;
-
-  /**
-   * Refresh token ID.
-   * This is used to check if refresh token is exists in DB and not revoked
-   */
-  id: string;
-
-}
-
-/**
- * Payload to create new JWT service token
- */
-export interface JwtServiceTokenPayload extends BaseJwtTokenPayload {
-  sub: JwtTokenType.SERVICE;
-
-  /**
-   * Audience. Service shortnames that can use this token
-   */
-  aud: string[];
-
-  /**
-   * Service token ID.
-   * This is used to check if service token is exists in DB and not revoked
-   */
-  id: string;
-
-  /**
-   * Client ID
-   * @example 'ext-simedia'
-   */
-  cid?: string;
-}
-
-/**
- * Decoded JWT access token
- */
-export interface JwtAccessToken extends JwtAccessTokenPayload {
-  /**
-   * Expiration time
-   */
-  exp: number;
-}
-
-/**
- * Decoded JWT access token
- */
-export interface JwtSubscriptionToken extends JwtSubscriptionTokenPayload {
-  /**
-   * Expiration time
-   */
-  exp: number;
-}
-
-/**
- * Decoded JWT refresh token
- */
-export interface JwtRefreshToken extends JwtRefreshTokenPayload {
-  /**
-   * Expiration time
-   */
-  exp: number;
-}
-
-/**
- * Decoded JWT service token
- */
-export interface JwtServiceToken extends JwtServiceTokenPayload {
-  /**
-   * Expiration time
-   */
-  exp?: number;
-}
-
-/**
- * Checks if the token is a JWT access token
- * @param token - The JWT token payload to check
- * @returns True if the token is an access token, false otherwise
- * @example
- * const payload = { sub: JwtTokenType.ACCESS, ... };
- * isJwtAccessToken(payload) // true
- */
-export const isJwtAccessToken = (token: BaseJwtTokenPayload): token is JwtAccessToken => {
-  return token.sub === JwtTokenType.ACCESS;
-};
-
-/**
- * Checks if the token is a JWT subscription token
- * @param token - The JWT token payload to check
- * @returns True if the token is a subscription token, false otherwise
- * @example
- * const payload = { sub: JwtTokenType.SUBSCRIPTION, ... };
- * isJwtSubscriptionToken(payload) // true
- */
-export const isJwtSubscriptionToken = (token: BaseJwtTokenPayload): token is JwtSubscriptionToken => {
-  return token.sub === JwtTokenType.SUBSCRIPTION;
-};
-
-/**
- * Checks if the token is a JWT refresh token
- * @param token - The JWT token payload to check
- * @returns True if the token is a refresh token, false otherwise
- * @example
- * const payload = { sub: JwtTokenType.REFRESH, ... };
- * isJwtRefreshToken(payload) // true
- */
-export const isJwtRefreshToken = (token: BaseJwtTokenPayload): token is JwtRefreshToken => {
-  return token.sub === JwtTokenType.REFRESH;
-};
-
-/**
- * Checks if the token is a JWT service token
- * @param token - The JWT token payload to check
- * @returns True if the token is a service token, false otherwise
- * @example
- * const payload = { sub: JwtTokenType.SERVICE, ... };
- * isJwtServiceToken(payload) // true
- */
-export const isJwtServiceToken = (token: BaseJwtTokenPayload): token is JwtServiceToken => {
-  return token.sub === JwtTokenType.SERVICE;
-};

package/src/logger/classes/logger-factory.ts

@@ -1,54 +0,0 @@
-import { Logger as WinstonLogger } from 'winston';
-
-import { LoggerContext } from '../logger.interfaces.js';
-import { Logger } from './logger.js';
-import { TypeOrmLogger, TypeOrmLoggerOptions } from './typeorm-logger.js';
-
-/**
- * Logger factory for creating loggers with predefined context
- * Factory is singleton, so it keep original winston `Logger` instance
- * and is can be injected to any service
- */
-export class LoggerFactory {
-  constructor(
-    private readonly winstonLogger: WinstonLogger,
-    private context: LoggerContext = {
-    },
-  ) {}
-
-  /**
-   * Created new logger with specific context merge it with global context
-   * @param context - specific action with scope, and other data
-   * @returns - new logger with context
-   * @example
-   * ```ts
-   * class SomeService {
-   *  logger: Logger;
-   *
-   *  constructor(
-   *   @InjectLoggerFactory() private readonly loggerFactory: LoggerFactory,
-   * ) {
-   *  // Create logger for this service
-   *  this.logger = this.loggerFactory.create({
-   *   scope: SomeService.name,
-   *  })
-   * }
-   * ```
-   */
-  create(context: LoggerContext = {
-  }) {
-    return new Logger(this.winstonLogger, {
-      ...this.context,
-      ...context,
-    });
-  }
-
-  createTypeOrmLogger(opts: Omit<TypeOrmLoggerOptions, 'logger'>) {
-    return new TypeOrmLogger({
-      logger: this.create({
-        scope: 'TypeORM',
-      }),
-      ...opts,
-    });
-  }
-}