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

package/src/modules/postgres-pubsub/postgres-pubsub.ts

@@ -1,461 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { isObject } from '#/tools/is-object.js';
-import { Injectable, OnModuleInit } from '@nestjs/common';
-import { Interval } from '@nestjs/schedule';
-import { InjectDataSource } from '@nestjs/typeorm';
-import { EventEmitter } from 'events';
-import { PubSubEngine } from 'graphql-subscriptions';
-import {
-  Client, ClientConfig, Notification, escapeIdentifier, escapeLiteral,
-} from 'pg';
-import {
-  BaseEntity, DataSource, FindOptionsWhere,
-} from 'typeorm';
-
-import { AppConfigType, InjectAppConfig } from '#/configs/app.config';
-import {
-  InjectLoggerFactory, Logger, LoggerFactory,
-} from '#/logger';
-import { MaybeNull } from '#/types/maybe';
-
-import { InjectDbConfig } from '#/configs/db.config';
-import { wait } from '#/tools/wait';
-import type { PostgresConnectionOptions } from 'typeorm/driver/postgres/PostgresConnectionOptions.js';
-
-export type PubSubSubscriptionCallback = (...args: unknown[]) => void;
-
-export interface PubSubSubscription {
-  id: number;
-  channel: string;
-  callback: PubSubSubscriptionCallback;
-}
-
-/**
- * Entity reference
- * @example
- * {
- *  __ref: 'Media#jsv:12jg839hkvgs'
- * }
- */
-export interface EntityRef {
-  __ref: string;
-}
-
-export interface EntityWithId extends BaseEntity {
-  id: string;
-}
-
-export interface ObjectWithId {
-  id: string;
-}
-
-@Injectable()
-export class PostgresPubSub extends PubSubEngine implements OnModuleInit {
-  @InjectAppConfig() declare protected readonly appConfig: AppConfigType;
-  @InjectDbConfig() declare protected readonly dbConfig: PostgresConnectionOptions;
-
-  @InjectLoggerFactory() declare private readonly loggerFactory: LoggerFactory;
-  declare protected logger: Logger;
-
-  @InjectDataSource() declare protected readonly dataSource: DataSource;
-
-  protected dbClient!: Client;
-  protected ee = new EventEmitter();
-  protected subscriptions: PubSubSubscription[] = [];
-
-  constructor(
-  ) {
-    super();
-  }
-
-  protected config!: ClientConfig;
-  protected readonly retryLimit = 5;
-  protected isReinitializing = false;
-
-  async onModuleInit() {
-    this.logger = this.loggerFactory.create({
-      scope: this.constructor.name,
-    });
-
-    this.config = {
-      host: this.dbConfig.host,
-      port: this.dbConfig.port,
-      database: this.dbConfig.database,
-      user: this.dbConfig.username,
-      password: this.dbConfig.password,
-      ssl: this.dbConfig.ssl as boolean | undefined,
-
-      // Pool configuration
-      connectionTimeoutMillis: 30000, // 30 seconds to establish connection
-
-      // Query timeout settings
-      query_timeout: 30000, // 30 seconds for queries to complete
-      statement_timeout: 30000, // 30 seconds for statements
-
-      // Automatic reconnection
-      keepAlive: true,
-      keepAliveInitialDelayMillis: 10000, // Start keep-alive after 10 seconds
-    };
-
-    await this.reinit();
-  }
-
-  // @see fix suggestion [here](https://community.fly.io/t/postgresql-connection-issues-have-returned/6424/6)
-  @Interval('KEEP_DB_CONNECTION_ALIVE', 5 * 1000) // each 5s
-  async keepDbConnectionAlive() {
-    if (this.isReinitializing) {
-      return;
-    }
-
-    try {
-      await this.dbClient.query('SELECT pg_backend_pid()');
-    } catch (error) {
-      if (error instanceof Error) {
-        this.logger.error('PubSub PostgreSQL connection check failed:', error);
-      }
-
-      await this.reinit();
-    }
-  }
-
-  protected async reinit() {
-    this.isReinitializing = true;
-
-    this.logger.info('🔌 Initializing PubSub PostgreSQL client...');
-
-    if (this.dbClient) {
-      this.dbClient.removeAllListeners();
-      this.dbClient.once('error', (error) => this.logger.error(`Previous DB client errored after reconnecting already:`, error));
-      this.dbClient.end();
-    }
-
-    this.dbClient = await this.reconnect();
-
-    this.logger.info('✅ PubSub PostgreSQL client connected');
-
-    this.addDbClientEventListeners();
-
-    this.isReinitializing = false;
-  }
-
-  protected addDbClientEventListeners() {
-    this.dbClient.on('notification', async (message: Notification) => {
-      await this.processNotification(message);
-    });
-
-    this.dbClient.on('end', async () => {
-      this.logger.warn('⛓️‍💥 PubSub PostgreSQL client ended');
-      if (!this.isReinitializing) {
-        await this.reinit();
-      }
-    });
-
-    this.dbClient.on('error', async (error: Error) => {
-      this.logger.error('🔴 PubSub PostgreSQL client error', error);
-
-      if (!this.isReinitializing) {
-        await this.reinit();
-      }
-    });
-  }
-
-  protected async reconnect() {
-    this.logger.info('🔌 Connecting to PubSub PostgreSQL for notification streaming');
-    const startTime = Date.now();
-    const retryTimeout = 3000;
-
-    for (let attempt = 1; attempt < this.retryLimit; attempt++) {
-      this.logger.info(`🔌 PostgreSQL connection attempt #${attempt}...`);
-
-      try {
-        const dbClient = new Client(this.config);
-        const connecting = new Promise((resolve, reject) => {
-          dbClient.once('connect', resolve);
-          dbClient.once('end', () => reject(Error('Connection ended.')));
-          dbClient.once('error', reject);
-        });
-        await Promise.all([
-          dbClient.connect(),
-          connecting,
-        ]);
-        this.logger.info('✅ PostgreSQL connection succeeded');
-
-        return dbClient;
-      } catch (error) {
-        if (error instanceof Error) {
-          this.logger.error('🔌 PostgreSQL connection attempt failed:', error);
-        }
-        await wait(500);
-
-        if (retryTimeout && (Date.now() - startTime) > retryTimeout) {
-          throw new Error(`🚫 Stopping PostgreSQL connection attempts after ${retryTimeout}ms timeout has been reached.`);
-        }
-      }
-    }
-
-    throw new Error('🔴 Reconnecting notification client to PostgreSQL database failed.');
-  }
-
-  public async publish(triggerName: string, payload: any, retryCount = 1): Promise<void> {
-    if (!payload) {
-      throw new Error('Payload is required argument');
-    }
-
-    const channel = escapeIdentifier(triggerName);
-
-    const message = escapeLiteral(JSON.stringify(this.minify(payload)));
-
-    // this.logger.info('Publish PostgreSQL notification', {
-    //   channel,
-    //   message,
-    //   payload,
-    // });
-
-    try {
-      await this.dbClient.query(`NOTIFY ${channel}, ${message}`);
-    } catch (error) {
-      if (error instanceof Error) {
-        this.logger.error(`Can't publish PostgreSQL notification to channel "${channel}"`, error, {
-          payload,
-        });
-
-        if (error.message.match(/connection/i)) {
-          if (retryCount < 3) {
-            this.logger.error(`Try to reconnect to PubSub PostgreSQL Client...(Retry count: ${retryCount})`);
-            await this.dbClient.end();
-            await this.dbClient.connect();
-            await this.publish(triggerName, payload, retryCount + 1);
-          }
-        }
-      }
-    }
-
-    return await Promise.resolve();
-  }
-
-  public async subscribe(triggerName: string, callback: PubSubSubscriptionCallback): Promise<number> {
-    if (!this.subscriptions.some((s) => s.channel === triggerName)) {
-      const channel = escapeIdentifier(triggerName);
-      await this.dbClient.query(`LISTEN ${channel}`);
-    }
-
-    this.ee.on(triggerName, callback);
-
-    const subId = Math.floor(Math.random() * 100000);
-
-    this.subscriptions.push({
-      id: subId,
-      channel: triggerName,
-      callback,
-    });
-
-    return await Promise.resolve(subId);
-  }
-
-  public async unsubscribe(subId: number) {
-    const index = this.subscriptions.findIndex((s) => s.id === subId);
-    if (index !== -1) {
-      const subscription = this.subscriptions[index];
-      this.subscriptions.splice(index, 1);
-      this.ee.removeListener(subscription.channel, subscription.callback);
-
-      if (!this.subscriptions.some((s) => s.channel === subscription.channel)) {
-        const channel = escapeIdentifier(subscription.channel);
-        await this.dbClient.query(`UNLISTEN ${channel}`);
-      }
-    }
-  }
-
-  private async processNotification(message: Notification) {
-    try {
-      const minifiedPayload = JSON.parse(message.payload || '');
-
-      // this.logger.info('Process PostgreSQL notification', {
-      //   channel: message.channel,
-      //   minifiedObject,
-      // });
-
-      if (minifiedPayload.id) {
-        if (Object.keys(minifiedPayload).length === 1) {
-          this.ee.emit(message.channel, minifiedPayload);
-        } else {
-          this.ee.emit(message.channel, await this.unminify(minifiedPayload));
-        }
-      } else if (Array.isArray(minifiedPayload)) {
-        const payload = await this.unminify(minifiedPayload);
-
-        this.ee.emit(message.channel, payload);
-      } else {
-        const payload: any = {
-        };
-        for (const [key, value] of Object.entries(minifiedPayload)) {
-          payload[key] = await this.unminify(value);
-        }
-
-        this.ee.emit(message.channel, payload);
-      }
-    } catch (error) {
-      if (error instanceof Error) {
-        this.logger.error(`Can't extract PostgreSQL notificaton from channel ${message.channel}`, error, {
-          message,
-        });
-      }
-    }
-  }
-
-  protected toRef(object: object): MaybeNull<EntityRef> {
-    // this.logger.info('Create reference', {
-    //   object,
-    //   isEntityWithId: this.isEntityWithId(object),
-    // });
-
-    if (this.isEntityWithId(object)) {
-      return {
-        __ref: `${object.constructor.name}#${object.id}`,
-      };
-    }
-
-    return null;
-  }
-
-  protected minify(payload: any): any {
-    if (Array.isArray(payload)) {
-      return payload.map((item) => this.minify(item));
-    }
-
-    if (!isObject(payload)) {
-      return payload;
-    }
-
-    // this.logger.info('Minifying object', {
-    //   object,
-    //   isEntityWithId: this.isEntityWithId(object),
-    // });
-
-    if (this.isEntityWithId(payload)) {
-      const ref = this.toRef(payload);
-
-      return (ref ?? payload);
-    }
-
-    const minifiedObject: Record<string, unknown> = {
-    };
-
-    for (const key of Object.keys(payload)) {
-      const value = payload[key];
-
-      if (value instanceof Date) {
-        minifiedObject[key] = value.toISOString();
-      } else if (Array.isArray(value)) {
-        minifiedObject[key] = value.map((item) => this.minify(item));
-      } else if (isObject(value)) {
-        minifiedObject[key] = this.minify(value);
-      } else {
-        minifiedObject[key] = value;
-      }
-    }
-
-    return minifiedObject;
-  }
-
-  protected async unref(entityRef: EntityRef): Promise<BaseEntity | ObjectWithId> {
-    const logger = this.logger.child({
-      action: this.unref.name,
-      entityRef,
-    });
-
-    // logger.info('Unref entity');
-
-    const [entityName, id] = entityRef.__ref.split('#');
-
-    if (!entityName || !id) {
-      logger.error(`Invalid ref ${entityRef.__ref}`);
-
-      return {
-        id: entityRef.__ref,
-      };
-    }
-
-    const entityMetadata = this.dataSource.entityMetadatas.find(
-      (entityMetadata) => entityMetadata.name === entityName,
-    );
-
-    if (!entityMetadata?.target) {
-      logger.error(`Entity ${entityName} not found in registry`);
-
-      return {
-        id,
-      };
-    }
-
-    const instance = await this.dataSource.getRepository(entityMetadata.target).findOneBy({
-      id,
-    } as FindOptionsWhere<EntityWithId>);
-
-    if (!instance) {
-      logger.error(`Entity ${entityName} with id ${id} not found in database`);
-
-      return {
-        id,
-      };
-    }
-
-    // logger.info('Unref entity success', {
-    //   instance,
-    // });
-
-    return instance as BaseEntity;
-  }
-
-  protected async unminify(payload: any): Promise<any> {
-    // this.logger.info('Unminifying object', {
-    //   object,
-    //   isEntityRef: this.isEntityRef(object),
-    // });
-
-    if (Array.isArray(payload)) {
-      return await Promise.all(payload.map((item) => this.unminify(item)));
-    }
-
-    if (this.isEntityRef(payload)) {
-      return await this.unref(payload);
-    }
-
-    if (!isObject(payload)) {
-      return payload;
-    }
-
-    const unminifiedObject: Record<string, unknown> = {
-    };
-
-    for (const key of Object.keys(payload)) {
-      const value = payload[key];
-
-      if (typeof value === 'string' && !isNaN(Date.parse(value))) {
-        unminifiedObject[key] = new Date(value);
-      } else if (this.isEntityRef(value)) {
-        unminifiedObject[key] = await this.unref(value);
-      } else if (Array.isArray(value)) {
-        unminifiedObject[key] = await Promise.all(value.map((item) => this.unminify(item)));
-      } else if (isObject(value)) {
-        unminifiedObject[key] = await this.unminify(value);
-      } else {
-        unminifiedObject[key] = value;
-      }
-    }
-
-    return unminifiedObject;
-  }
-
-  protected isEntityRef(value: unknown): value is EntityRef {
-    return typeof value === 'object' && value !== null && '__ref' in value;
-  }
-
-  protected isEntityWithId(value: unknown): value is EntityWithId {
-    return value instanceof BaseEntity && 'id' in value;
-  }
-
-  public asyncIterator<T>(triggers: string | readonly string[]) {
-    return super.asyncIterableIterator(triggers) as AsyncIterator<T>;
-  }
-}

package/src/pagination/constants.ts

@@ -1,9 +0,0 @@
-/**
- * Pagination max limit value
- */
-export const PAGINATION_MAX_LIMIT = 1000;
-
-/**
- * Pagination default limit value
- */
-export const PAGINATION_DEFAULT_LIMIT = 20;

package/src/pagination/cursor/cursor-pagination.exception.ts

@@ -1,16 +0,0 @@
-import { NestError } from '#/errors';
-
-export enum CursorErrorMessage {
-  CURSOR = 'Invalid cursor',
-  FIRST_OR_LAST = `Should pass exactly one of arguments ('first'/'last')`,
-}
-
-export class InvalidCursorError extends NestError {
-  constructor(public message: CursorErrorMessage) {
-    super({
-      message,
-      key: 'NST_CURSOR_INVALID',
-    });
-    this.name = 'InvalidCursorError';
-  }
-}

package/src/pagination/cursor/cursor-pagination.helpers.ts

@@ -1,145 +0,0 @@
-import { truncPaginationLimit } from '../tools.js';
-import { CursorErrorMessage, InvalidCursorError } from './cursor-pagination.exception.js';
-import { CursorPaginationInput } from './cursor-pagination.input.js';
-import {
-  CursorOrderBy, CursorPaginationPageInfo, ICursorPaginated,
-} from './cursor-pagination.types.js';
-
-/**
- * Encode cursor string to base64.
- * @param str - Cursor string.
- * @example
- * const cursor = '2020-01-01T00:00:00.000Z';
- * // encoded = 'MjAyMC0wMS0wMVQwMDowMDowMC4wMDBa';
- */
-const encodeCursor = (str: string): string => {
-  return Buffer
-    .from(str)
-    .toString('base64');
-};
-
-/**
- * Decode cursor string from base64.
- * @param encoded - Encoded cursor string (base64).
- * @example
- * const encoded = 'MjAyMC0wMS0wMVQwMDowMDowMC4wMDBa';
- * // cursor = '2020-01-01T00:00:00.000Z';
- */
-const decodeCursor = (encoded: string): string => {
-  return Buffer
-    .from(encoded, 'base64')
-    .toString('binary');
-};
-
-export interface CursorPaginationFilter {
-  /**
-   * Return only items created after this date.
-   **/
-  createdAfter?: Date;
-
-  /**
-   * Return only items created before this date.
-   * */
-  createdBefore?: Date;
-}
-
-export interface CursorPaginationOptions {
-  /**
-   * Limit of items to return.
-   */
-  limit?: number;
-
-  /**
-   * Filter options.
-   */
-  filter: CursorPaginationFilter;
-
-  /**
-   * Order by options.
-   */
-  orderBy: CursorOrderBy;
-
-  /**
-   * If true, the total count of items will be returned.
-   */
-  needCountTotal: false;
-}
-
-export const createCursorPaginationOptions = (meta: CursorPaginationInput): CursorPaginationOptions => {
-  const {
-    first,
-    last,
-    before,
-    after,
-  } = meta;
-
-  if ((!first && !last) || (first && last)) {
-    throw new InvalidCursorError(CursorErrorMessage.FIRST_OR_LAST);
-  }
-
-  const options: CursorPaginationOptions = {
-    filter: {
-    },
-    needCountTotal: false,
-
-    // If first is provided, we need to sort in ascending order, otherwise descending.
-    orderBy: first ? CursorOrderBy.createdAt_ASC : CursorOrderBy.createdAt_DESC,
-  };
-
-  /**
-   * If first or last is provided, we need to add 1 to the limit to determine if there is a next or previous page.
-   */
-  options.limit = truncPaginationLimit(first ?? last as number) + 1;
-
-  if (after) {
-    options.filter.createdAfter = new Date(decodeCursor(after));
-  }
-
-  if (before) {
-    options.filter.createdBefore = new Date(decodeCursor(before));
-  }
-
-  return options;
-};
-
-export const cursorPaginationOutput = <T extends { createdAt: Date }>(nodes: T[], meta: CursorPaginationInput): ICursorPaginated<T> => {
-  const {
-    first,
-    last,
-    after,
-    before,
-  } = meta;
-  const pageInfo: CursorPaginationPageInfo = new CursorPaginationPageInfo();
-  const limit = truncPaginationLimit(first ?? last as number);
-  const hasOneMorePage: boolean = nodes.length > limit;
-
-  pageInfo.hasPreviousPage = (last && hasOneMorePage) || !!after;
-  pageInfo.hasNextPage = (first && hasOneMorePage) || !!before;
-
-  if (hasOneMorePage) {
-    nodes.pop();
-  }
-
-  if (last) {
-    nodes.reverse();
-  }
-
-  const edges = nodes.map((value) => {
-    const createdAtStr = value.createdAt instanceof Date
-      ? value.createdAt.toISOString()
-      : value.createdAt;
-
-    return {
-      node: value,
-      cursor: encodeCursor(createdAtStr),
-    };
-  });
-
-  pageInfo.startCursor = edges.length > 0 ? edges[0].cursor : null;
-  pageInfo.endCursor = edges.length > 0 ? edges.at(-1)?.cursor ?? null : null;
-
-  return {
-    edges,
-    pageInfo,
-  };
-};