@ask-ell/back-end 0.1.1 → 0.2.3

package/src/scripts/move-keyv-data.script.ts

@@ -3,65 +3,86 @@ import { Script, ExecuteOptions } from '@ask-ell/node';
 import { NestLogger } from '@ask-ell/nest';
 import { Client, QueryResult } from 'pg';
 
-
 type KeyvRowData<Value = unknown> = {
-    key: string;
-    value: Value;
-}
+  key: string;
+  value: Value;
+};
 
 export class MoveKeyvDataScript extends Script {
-    constructor() {
-        super({
-            arguments: [
-                { name: 'origin', description: 'Origin Postgres database URI', required: true },
-                { name: 'target', description: 'Target Postgres database URI', required: true }
-            ],
-            logger: NestLogger.fromClass(MoveKeyvDataScript)
-        });
-    }
+  constructor() {
+    super({
+      arguments: [
+        {
+          name: 'origin',
+          description: 'Origin Postgres database URI',
+          required: true,
+        },
+        {
+          name: 'target',
+          description: 'Target Postgres database URI',
+          required: true,
+        },
+      ],
+      logger: NestLogger.fromClass(MoveKeyvDataScript),
+    });
+  }
 
-    async execute({ logger, arguments: { origin, target }, prompts: { confirm } }: ExecuteOptions): Promise<void> {
-        const originPostgresClient: Client = new Client(origin);
-        const targetPostgresClient: Client = new Client(target);
+  async execute({
+    logger,
+    arguments: { origin, target },
+    prompts: { confirm },
+  }: ExecuteOptions): Promise<void> {
+    const originPostgresClient: Client = new Client(origin);
+    const targetPostgresClient: Client = new Client(target);
 
-        logger.log('Reading databases...');
+    logger.log('Reading databases...');
 
-        await Promise.all([
-            originPostgresClient.connect(),
-            targetPostgresClient.connect()
-        ]);
+    await Promise.all([
+      originPostgresClient.connect(),
+      targetPostgresClient.connect(),
+    ]);
 
-        try {
-            const { rows }: QueryResult<KeyvRowData> = await originPostgresClient.query('SELECT * FROM keyv');
+    try {
+      const { rows }: QueryResult<KeyvRowData> =
+        await originPostgresClient.query('SELECT * FROM keyv');
 
-            const rowsCount: number = rows.length;
-            logger.log(`You're going to insert ${rowsCount} keyv entries from the original database to the target database.`);
+      const rowsCount: number = rows.length;
+      logger.log(
+        `You're going to insert ${rowsCount} keyv entries from the original database to the target database.`
+      );
 
-            const confirmed: boolean = await confirm('Are you sure you want to proceed?');
+      const confirmed: boolean = await confirm(
+        'Are you sure you want to proceed?'
+      );
 
-            if (confirmed) {
-                logger.log('Inserting entries into the target database...');
-                const incrementor: PercentageIncrementor = new PercentageIncrementor(rowsCount);
-                incrementor.onIncrement(({ achivmentOnPercent }): void => {
-                    logger.log(`Progress: ${achivmentOnPercent}%`);
-                });
-
-                for (const { key, value } of rows) {
-                    await targetPostgresClient.query('INSERT INTO keyv (key, value) VALUES ($1, $2)', [key, value]);
-                    incrementor.increment();
-                }
+      if (confirmed) {
+        logger.log('Inserting entries into the target database...');
+        const incrementor: PercentageIncrementor = new PercentageIncrementor(
+          rowsCount
+        );
+        incrementor.onIncrement(({ achivmentOnPercent }): void => {
+          logger.log(`Progress: ${achivmentOnPercent}%`);
+        });
 
-                logger.log(`${rowsCount} entries inserted into the target database.`);
-                logger.log('Migration completed successfully.');
-            } else {
-                logger.log('Migration cancelled.');
-            }
-        } finally {
-            await Promise.all([
-                originPostgresClient.end(),
-                targetPostgresClient.end()
-            ]);
-            logger.log('Database connections closed.');
+        for (const { key, value } of rows) {
+          await targetPostgresClient.query(
+            'INSERT INTO keyv (key, value) VALUES ($1, $2)',
+            [key, value]
+          );
+          incrementor.increment();
         }
+
+        logger.log(`${rowsCount} entries inserted into the target database.`);
+        logger.log('Migration completed successfully.');
+      } else {
+        logger.log('Migration cancelled.');
+      }
+    } finally {
+      await Promise.all([
+        originPostgresClient.end(),
+        targetPostgresClient.end(),
+      ]);
+      logger.log('Database connections closed.');
     }
+  }
 }

package/src/scripts/update-dependencies-versions.script.ts

@@ -1,167 +1,201 @@
-import { MaybeUndefined, StringDictionnary, UnknownEnvironmentVariableError } from "@ask-ell/core";
-import { NestLogger } from "@ask-ell/nest";
-import { ExecuteOptions, Script } from "@ask-ell/node";
+import {
+  MaybeUndefined,
+  StringDictionnary,
+  UnknownEnvironmentVariableError,
+} from '@ask-ell/core';
+import { NestLogger } from '@ask-ell/nest';
+import { ExecuteOptions, Script } from '@ask-ell/node';
 import { spawnSync } from 'node:child_process';
-import { writeFileSync } from "node:fs";
+import { writeFileSync } from 'node:fs';
 import { mkdir } from 'node:fs/promises';
 import { join } from 'node:path';
 
-
 const PROJECT_ROOT_PATH: MaybeUndefined<string> = process.env['PWD'];
 
-function makeSureThatProjectRootPathIsDefined(projectRootPath: MaybeUndefined<string>): asserts projectRootPath is string {
-    if (!projectRootPath) {
-        throw new UnknownEnvironmentVariableError('PWD');
-    }
+function makeSureThatProjectRootPathIsDefined(
+  projectRootPath: MaybeUndefined<string>
+): asserts projectRootPath is string {
+  if (!projectRootPath) {
+    throw new UnknownEnvironmentVariableError('PWD');
+  }
 }
 
 makeSureThatProjectRootPathIsDefined(PROJECT_ROOT_PATH);
 
 const NX_GRAPH_FILE_PATH: string = join(PROJECT_ROOT_PATH, 'tmp/graph.json');
 
-type PackageContent = {
-    version: string;
-    dependencies: StringDictionnary;
-    devDependencies: StringDictionnary;
+export type PackageContent = {
+  version: string;
+  dependencies: StringDictionnary;
+  devDependencies: StringDictionnary;
 };
 
 const ROOT_PACKAGE_FILE_PATH: string = join(PROJECT_ROOT_PATH, `package.json`);
 const ROOT_PACKAGE_CONTENT: PackageContent = require(ROOT_PACKAGE_FILE_PATH);
 
-
 function getOrganisationPackageFile(packageId: string): PackageContent {
-    makeSureThatProjectRootPathIsDefined(PROJECT_ROOT_PATH);
-    const packageFilePath = join(PROJECT_ROOT_PATH, `packages/${packageId}/package.json`);
-    return require(packageFilePath);
+  makeSureThatProjectRootPathIsDefined(PROJECT_ROOT_PATH);
+  const packageFilePath = join(
+    PROJECT_ROOT_PATH,
+    `packages/${packageId}/package.json`
+  );
+  return require(packageFilePath);
 }
 
-type UpdateDependenciesVersionsScriptParams = {
-    organisationPackagePrefix: string;
-    blackListedPackages: string[];
-}
+export type UpdateDependenciesVersionsScriptParams = {
+  organisationPackagePrefix: string;
+  blackListedPackages: string[];
+};
 
-type WorkspaceDependenciesMapElement = { id: string; dependencies: string[]; source: PackageContent };
+export type WorkspaceDependenciesMapElement = {
+  id: string;
+  dependencies: string[];
+  source: PackageContent;
+};
 
-type WorkspaceDependenciesMap = {
-    [id: string]: WorkspaceDependenciesMapElement;
+export type WorkspaceDependenciesMap = {
+  [id: string]: WorkspaceDependenciesMapElement;
 };
 
 export class UpdateDependenciesVersionsScript extends Script {
-    private organisationPackagePrefix: string;
-    private blackListedPackages: string[];
-    private workspaceDependenciesMap: WorkspaceDependenciesMap = this.getWorkspaceDependenciesMap();
-
-    constructor({
-        organisationPackagePrefix,
-        blackListedPackages
-    }: UpdateDependenciesVersionsScriptParams) {
-        super({
-            logger: NestLogger.fromClass(UpdateDependenciesVersionsScript),
-            arguments: [
-                {
-                    name: 'targetedPackage',
-                    description: "Target package"
-                }
-            ]
-        });
-        this.organisationPackagePrefix = organisationPackagePrefix;
-        this.blackListedPackages = blackListedPackages;
+  private organisationPackagePrefix: string;
+  private blackListedPackages: string[];
+  private workspaceDependenciesMap: WorkspaceDependenciesMap =
+    this.getWorkspaceDependenciesMap();
+
+  constructor({
+    organisationPackagePrefix,
+    blackListedPackages,
+  }: UpdateDependenciesVersionsScriptParams) {
+    super({
+      logger: NestLogger.fromClass(UpdateDependenciesVersionsScript),
+      arguments: [
+        {
+          name: 'targetedPackage',
+          description: 'Target package',
+        },
+      ],
+    });
+    this.organisationPackagePrefix = organisationPackagePrefix;
+    this.blackListedPackages = blackListedPackages;
+  }
+
+  async execute({
+    logger,
+    arguments: { targetedPackage },
+  }: ExecuteOptions): Promise<void> {
+    const workspaceDependenciesMapElements: WorkspaceDependenciesMapElement[] =
+      Object.values(this.workspaceDependenciesMap).filter(
+        ({ id }: WorkspaceDependenciesMapElement): boolean =>
+          this.isTargetedPackage(targetedPackage)(id)
+      );
+
+    for (const {
+      id,
+      dependencies,
+      source,
+    } of workspaceDependenciesMapElements) {
+      logger.log(`package.json file updating for project "${id}"...`);
+
+      if (!PROJECT_ROOT_PATH) {
+        throw new UnknownEnvironmentVariableError('PWD');
+      }
+      const packagePath: string = join(
+        PROJECT_ROOT_PATH,
+        `dist/packages/${id}`
+      );
+
+      await mkdir(packagePath, { recursive: true });
+      const packageFilePath: string = join(PROJECT_ROOT_PATH, 'package.json');
+
+      const packageFileContent: PackageContent = { ...source };
+
+      if (dependencies.length && !packageFileContent.dependencies) {
+        packageFileContent.dependencies = {};
+      }
+
+      dependencies.forEach((dependency: string): void => {
+        const versionTag = this.isAOrganisationPackage(dependency)
+          ? `^${
+              this.workspaceDependenciesMap[
+                dependency.replace(this.organisationPackagePrefix, '')
+              ].source.version
+            }`
+          : ROOT_PACKAGE_CONTENT.devDependencies[dependency];
+        packageFileContent.dependencies[dependency] = versionTag;
+      });
+
+      writeFileSync(
+        packageFilePath,
+        JSON.stringify(packageFileContent, null, 2) + '\n'
+      );
+
+      console.log(`package.json file updated for project "${id}"`);
     }
 
-    async execute({
-        logger,
-        arguments: {
-            targetedPackage
-        }
-    }: ExecuteOptions): Promise<void> {
-        const workspaceDependenciesMapElements: WorkspaceDependenciesMapElement[] = Object
-                .values(this.workspaceDependenciesMap)
-                .filter(({ id }: WorkspaceDependenciesMapElement): boolean => this.isTargetedPackage(targetedPackage)(id));
-
-        for (const { id, dependencies, source } of workspaceDependenciesMapElements) {
-            logger.log(`package.json file updating for project "${id}"...`);
-
-            if (!PROJECT_ROOT_PATH) {
-                throw new UnknownEnvironmentVariableError('PWD');
-            }
-            const packagePath: string = join(PROJECT_ROOT_PATH, `dist/packages/${id}`);
-
-            await mkdir(packagePath, { recursive: true });
-            const packageFilePath: string = join(PROJECT_ROOT_PATH, 'package.json');
-
-            const packageFileContent: PackageContent = { ...source };
-
-            if (dependencies.length && !packageFileContent.dependencies) {
-                packageFileContent.dependencies = {};
-            }
+    console.log('Package files updated.');
+  }
 
-            dependencies.forEach((dependency: string): void => {
-                const versionTag = this.isAOrganisationPackage(dependency)
-                    ? `^${this.workspaceDependenciesMap[dependency.replace(this.organisationPackagePrefix, '')].source.version}`
-                    : ROOT_PACKAGE_CONTENT.devDependencies[dependency];
-                packageFileContent.dependencies[dependency] = versionTag;
-            });
+  getWorkspaceDependenciesMap(): WorkspaceDependenciesMap {
+    const workspaceDependenciesMap: WorkspaceDependenciesMap = {};
 
-            writeFileSync(
-                packageFilePath,
-                JSON.stringify(packageFileContent, null, 2) + '\n'
-            );
-
-            console.log(`package.json file updated for project "${id}"`);
-        }
-
-        console.log('Package files updated.')
+    const nxGraphResult = spawnSync(
+      'npx',
+      ['nx', 'graph', '--file', NX_GRAPH_FILE_PATH],
+      { stdio: 'inherit' }
+    );
+    if (nxGraphResult.status !== 0) {
+      throw new Error(`"nx graph" failed with status ${nxGraphResult.status}`);
     }
-
-    getWorkspaceDependenciesMap(): WorkspaceDependenciesMap {
-        const workspaceDependenciesMap: WorkspaceDependenciesMap = {};
-
-        const nxGraphResult = spawnSync('npx', ['nx', 'graph', '--file', NX_GRAPH_FILE_PATH], { stdio: 'inherit' });
-        if (nxGraphResult.status !== 0) {
-            throw new Error(`"nx graph" failed with status ${nxGraphResult.status}`);
-        }
-        const nxGraph = require(NX_GRAPH_FILE_PATH);
-
-        const packageIds = Object.entries(nxGraph.graph.dependencies).map(([packageId]) => packageId);
-
-        for (const packageId of packageIds.filter(this.isNotBlackListed)) {
-            console.log(`Scanning dependencies for package ${packageId}...`)
-            const packageFileContent = getOrganisationPackageFile(packageId);
-            const dependencies = packageFileContent.dependencies ? Object.entries(packageFileContent.dependencies).map(([dependency]) => dependency) : [];
-
-            workspaceDependenciesMap[packageId] = {
-                id: packageId,
-                dependencies: [],
-                source: packageFileContent
-            }
-            if (packageFileContent.dependencies) {
-                for (const dependency of dependencies) {
-                    workspaceDependenciesMap[packageId].dependencies.push(dependency);
-                }
-            }
+    const nxGraph = require(NX_GRAPH_FILE_PATH);
+
+    const packageIds = Object.entries(nxGraph.graph.dependencies).map(
+      ([packageId]) => packageId
+    );
+
+    for (const packageId of packageIds.filter(this.isNotBlackListed)) {
+      console.log(`Scanning dependencies for package ${packageId}...`);
+      const packageFileContent = getOrganisationPackageFile(packageId);
+      const dependencies = packageFileContent.dependencies
+        ? Object.entries(packageFileContent.dependencies).map(
+            ([dependency]) => dependency
+          )
+        : [];
+
+      workspaceDependenciesMap[packageId] = {
+        id: packageId,
+        dependencies: [],
+        source: packageFileContent,
+      };
+      if (packageFileContent.dependencies) {
+        for (const dependency of dependencies) {
+          workspaceDependenciesMap[packageId].dependencies.push(dependency);
         }
+      }
+    }
 
-        console.log('Dependencies scan done.');
+    console.log('Dependencies scan done.');
 
-        return workspaceDependenciesMap;
-    }
+    return workspaceDependenciesMap;
+  }
 
-    private isTargetedPackage = (targetPackageId: MaybeUndefined<string>) => (packageId: string) => {
-        if (targetPackageId) {
-            return packageId === targetPackageId;
-        }
-        return true;
-    }
+  private isTargetedPackage =
+    (targetPackageId: MaybeUndefined<string>) => (packageId: string) => {
+      if (targetPackageId) {
+        return packageId === targetPackageId;
+      }
+      return true;
+    };
 
-    private isAOrganisationPackage(packageName: string): boolean {
-        return packageName.includes(this.organisationPackagePrefix);
-    }
+  private isAOrganisationPackage(packageName: string): boolean {
+    return packageName.includes(this.organisationPackagePrefix);
+  }
 
-    private isBlackListed(packageId: string): boolean {
-        return this.blackListedPackages.includes(packageId);
-    }
+  private isBlackListed(packageId: string): boolean {
+    return this.blackListedPackages.includes(packageId);
+  }
 
-    private isNotBlackListed(packageId: string): boolean {
-        return !this.isBlackListed(packageId);
-    }
-}
+  private isNotBlackListed(packageId: string): boolean {
+    return !this.isBlackListed(packageId);
+  }
+}

package/src/secrets/docker.secret.getter.ts

@@ -1,8 +1,9 @@
-import { FileSecretGetter, fileSecretGetter } from "./file.secret.getter";
-
+import { FileSecretGetter, fileSecretGetter } from './file.secret.getter';
 
 const DOCKER_SECRETS_DIRECTORY = '/run/secrets';
 
-export const dockerSecretGetter: FileSecretGetter = fileSecretGetter
-    (DOCKER_SECRETS_DIRECTORY)
-    ('Application is not running inside Docker container. Docker secrets will be unavailable.')
+export const dockerSecretGetter: FileSecretGetter = fileSecretGetter(
+  DOCKER_SECRETS_DIRECTORY
+)(
+  'Application is not running inside Docker container. Docker secrets will be unavailable.'
+);

package/src/secrets/file.secret.getter.ts

@@ -1,24 +1,27 @@
-import { Dirent, existsSync, readdirSync, readFileSync } from "node:fs";
-import { join } from "node:path";
-import { ILogger } from "@ask-ell/core";
-
-import { SecretGetter } from "./types";
+import { Dirent, existsSync, readdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { ILogger } from '@ask-ell/core';
 
+import { SecretGetter } from './types';
 
 export type FileSecretGetter = (logger: ILogger) => SecretGetter;
 
-export const fileSecretGetter = (rootDirectoryPath: string) => (warningMessage: string): FileSecretGetter => (logger: ILogger): SecretGetter => (): object => {
+export const fileSecretGetter =
+  (rootDirectoryPath: string) =>
+  (warningMessage: string): FileSecretGetter =>
+  (logger: ILogger): SecretGetter =>
+  (): object => {
     const isDirectoryExists: boolean = existsSync(rootDirectoryPath);
-    if(!isDirectoryExists){
-        logger.warn(warningMessage);
-        return {};
+    if (!isDirectoryExists) {
+      logger.warn(warningMessage);
+      return {};
     }
 
     return readdirSync(rootDirectoryPath, { withFileTypes: true })
-        .filter((entry: Dirent<string>): boolean => entry.isFile())
-        .reduce((secrets: Record<string, string>, entry): object => {
-            const filePath: string = join(rootDirectoryPath, entry.name);
-            secrets[entry.name] = readFileSync(filePath, 'utf-8').trim();
-            return secrets;
-        }, {});
-}
+      .filter((entry: Dirent<string>): boolean => entry.isFile())
+      .reduce((secrets: Record<string, string>, entry): object => {
+        const filePath: string = join(rootDirectoryPath, entry.name);
+        secrets[entry.name] = readFileSync(filePath, 'utf-8').trim();
+        return secrets;
+      }, {});
+  };

package/src/secrets/index.ts

@@ -1,2 +1,2 @@
-export * from './docker.secret.getter'
-export * from './local.secret.getter'
+export * from './docker.secret.getter';
+export * from './local.secret.getter';

package/src/secrets/local.secret.getter.ts

@@ -1,8 +1,9 @@
-import { fileSecretGetter, FileSecretGetter } from "./file.secret.getter";
-
+import { fileSecretGetter, FileSecretGetter } from './file.secret.getter';
 
 const LOCAL_SECRETS_DIRECTORY = '.secrets';
 
-export const localSecretGetter: FileSecretGetter = fileSecretGetter
-    (LOCAL_SECRETS_DIRECTORY)
-    ('Secrets directory not exists on this project. Local secrets will be unavailable.');
+export const localSecretGetter: FileSecretGetter = fileSecretGetter(
+  LOCAL_SECRETS_DIRECTORY
+)(
+  'Secrets directory not exists on this project. Local secrets will be unavailable.'
+);

package/src/tmp.ts

@@ -0,0 +1,15 @@
+import { ILogger } from '@ask-ell/core';
+import { existsSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+
+export const TMP_FOLDER_PATH: string = join(process.cwd(), 'tmp');
+
+export const createTmpFolder = (logger: ILogger): void => {
+  const isTmpFolderExists: boolean = existsSync(TMP_FOLDER_PATH);
+  if (isTmpFolderExists) {
+    logger.info(`"${TMP_FOLDER_PATH}" folder already exists.`);
+    return;
+  }
+  mkdirSync(TMP_FOLDER_PATH);
+  logger.info(`"${TMP_FOLDER_PATH}" folder created.`);
+};

package/src/add-ons/add-on.interface.ts

@@ -1,5 +0,0 @@
-import { INestApplication } from "@nestjs/common";
-
-export interface IAddOn<T> {
-        apply(application: INestApplication<T>): void;
-}

package/src/add-ons/add-on.wrapper.ts

@@ -1,36 +0,0 @@
-import { INestApplication } from "@nestjs/common";
-
-import { IAddOn } from "./add-on.interface";
-import { SecurityAddOn } from "./implementations/security/security.add-on";
-import { AddOnWrapperParams } from "./types";
-import { SwaggerAddon } from "./implementations/swagger/swagger.add-on";
-import { SentryAddon } from "./implementations/sentry/sentry.add-on";
-
-
-export class AddOnWrapper<T> implements IAddOn<T> {
-    private implementations: IAddOn<T>[] = [
-        new SecurityAddOn()
-    ];
-
-    constructor(
-        private params: AddOnWrapperParams
-    ) {
-        this.appendImplementations();
-    }
-
-    apply(application: INestApplication<T>): void {
-        this.implementations.forEach((addOn: IAddOn<T>): void => {
-            addOn.apply(application);
-        });
-    }
-
-    private appendImplementations(): void {
-        const { sentry, swagger } = this.params;
-        if(swagger){
-            this.implementations.push(new SwaggerAddon(swagger));
-        }
-        if(sentry){
-            this.implementations.push(new SentryAddon(sentry));
-        }
-    }
-}

package/src/add-ons/implementations/sentry/sentry.add-on.interface.ts

@@ -1,8 +0,0 @@
-import { IEntity } from "@ask-ell/core";
-
-import { ISentryAddOnState } from "./sentry.add-on.state.interface";
-import { IAddOn } from "../../add-on.interface";
-
-
-export interface ISentryAddOn<T>
-  extends IEntity<ISentryAddOnState>, IAddOn<T> { }

package/src/add-ons/implementations/swagger/swagger.add-on.interface.ts

@@ -1,7 +0,0 @@
-import { IEntity } from "@ask-ell/core";
-
-import { ISwaggerAddOnState } from "./swagger.add-on.state.interface";
-import { IAddOn } from "../../add-on.interface";
-
-export interface ISwaggerAddOn<T>
-  extends IEntity<ISwaggerAddOnState>, IAddOn<T> { }