@ask-ell/back-end 0.1.0 → 0.2.1

package/jest.config.ts

@@ -1,4 +1,3 @@
-/* eslint-disable */
 import { readFileSync } from 'fs';
 
 // Reading the SWC compilation config for the spec files

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ask-ell/back-end",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "private": false,
   "type": "commonjs",
   "main": "./src/index.js",
@@ -20,6 +20,7 @@
     "helmet": "*",
     "keyv": "*",
     "pg": "*",
-    "tslib": "*"
+    "tslib": "*",
+    "rxjs": "*"
   }
 }

package/project.json

@@ -8,22 +8,19 @@
     "build": {
       "executor": "@nx/js:tsc",
       "dependsOn": ["^build"],
-      "outputs": [
-        "{options.outputPath}"
-      ],
+      "outputs": ["{options.outputPath}"],
       "options": {
         "outputPath": "dist/packages/back-end",
         "main": "packages/back-end/src/index.ts",
         "tsConfig": "packages/back-end/tsconfig.lib.json",
-        "assets": [
-          "packages/back-end/*.md"
-        ]
+        "assets": ["packages/back-end/*.md"]
       }
     },
     "test": {
       "options": {
         "passWithNoTests": true
       }
-    }
+    },
+    "format": {}
   }
 }

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

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

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

@@ -1,36 +1,31 @@
-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";
+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()
-    ];
+  private implementations: IAddOn<T>[] = [new SecurityAddOn()];
 
-    constructor(
-        private params: AddOnWrapperParams
-    ) {
-        this.appendImplementations();
-    }
+  constructor(private params: AddOnWrapperParams) {
+    this.appendImplementations();
+  }
 
-    apply(application: INestApplication<T>): void {
-        this.implementations.forEach((addOn: IAddOn<T>): void => {
-            addOn.apply(application);
-        });
-    }
+  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));
-        }
+  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/security/security.add-on.ts

@@ -1,8 +1,7 @@
-import { INestApplication, ValidationPipe } from "@nestjs/common";
+import { INestApplication, ValidationPipe } from '@nestjs/common';
 import helmet from 'helmet';
 
-import { IAddOn } from "../../add-on.interface";
-
+import { IAddOn } from '../../add-on.interface';
 
 export class SecurityAddOn<T> implements IAddOn<T> {
   apply(application: INestApplication<T>): void {
@@ -11,7 +10,7 @@ export class SecurityAddOn<T> implements IAddOn<T> {
     application.useGlobalPipes(
       new ValidationPipe({
         transform: true,
-        whitelist: false
+        whitelist: false,
       })
     );
   }

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

@@ -1,8 +1,8 @@
-import { IEntity } from "@ask-ell/core";
-
-import { ISentryAddOnState } from "./sentry.add-on.state.interface";
-import { IAddOn } from "../../add-on.interface";
+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> { }
+  extends IEntity<ISentryAddOnState>,
+    IAddOn<T> {}

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

@@ -2,4 +2,4 @@ export interface ISentryAddOnState {
   publicKey: string;
   host: string;
   projectId: string;
-}
+}

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

@@ -1,15 +1,14 @@
-import { Entity, type IResult, ok } from "@ask-ell/core";
-import { NestSentryConfiguration } from "@ask-ell/nest"
-
-import { ISentryAddOnState } from "./sentry.add-on.state.interface";
-import { ISentryAddOn } from "./sentry.add-on.interface";
+import { Entity, type IResult, ok } from '@ask-ell/core';
+import { NestSentryConfiguration } from '@ask-ell/nest';
 
+import { ISentryAddOnState } from './sentry.add-on.state.interface';
+import { ISentryAddOn } from './sentry.add-on.interface';
 
 export class SentryAddon<T>
   extends Entity<ISentryAddOnState>
   implements ISentryAddOn<T>
 {
-  checkStateValidity(_newState: ISentryAddOnState): IResult<void> {
+  checkStateValidity(): IResult<void> {
     return ok();
   }
 
@@ -17,9 +16,9 @@ export class SentryAddon<T>
     const { host, projectId, publicKey } = this.getSnapshot();
 
     new NestSentryConfiguration({
-        publicKey,
-        host,
-        projectId
+      publicKey,
+      host,
+      projectId,
     }).init();
   }
-}
+}

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

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

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

@@ -1,6 +1,7 @@
-import { AuthMethod } from "./types";
+import { AuthMethod } from './types';
 
 export interface ISwaggerAddOnState {
   title: string;
   auths?: AuthMethod[];
-}
+  enabledInProduction?: boolean;
+}

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

@@ -1,28 +1,42 @@
-import { Entity, type IResult, ok } from "@ask-ell/core";
-import { type INestApplication } from "@nestjs/common";
+import {
+  Entity,
+  ILogger,
+  type IResult,
+  isOnDevelopmentMode,
+  ok,
+} from '@ask-ell/core';
+import { NestLogger } from '@ask-ell/nest';
+import { type INestApplication } from '@nestjs/common';
 import {
   DocumentBuilder,
   type OpenAPIObject,
   SwaggerModule,
-} from "@nestjs/swagger";
-
-import { ISwaggerAddOnState } from "./swagger.add-on.state.interface";
-import { ISwaggerAddOn } from "./swagger.add-on.interface";
-import { AuthMethod } from "./types";
+} from '@nestjs/swagger';
 
+import { ISwaggerAddOnState } from './swagger.add-on.state.interface';
+import { ISwaggerAddOn } from './swagger.add-on.interface';
+import { AuthMethod } from './types';
 
 export class SwaggerAddon<T>
   extends Entity<ISwaggerAddOnState>
   implements ISwaggerAddOn<T>
 {
-  checkStateValidity(_newState: ISwaggerAddOnState): IResult<void> {
+  private logger: ILogger = NestLogger.fromClass(SwaggerAddon);
+
+  checkStateValidity(): IResult<void> {
     return ok();
   }
 
   apply(application: INestApplication<T>): void {
-    const { title, auths } = this.getSnapshot();
+    const { title, auths, enabledInProduction } = this.getSnapshot();
 
-    const documentBuilder: DocumentBuilder = new DocumentBuilder().setTitle(title)
+    if (!enabledInProduction && !isOnDevelopmentMode()) {
+      return;
+    }
+
+    const documentBuilder: DocumentBuilder = new DocumentBuilder().setTitle(
+      title
+    );
 
     auths?.forEach((auth: AuthMethod): void => {
       if (auth === 'bearer') {
@@ -30,14 +44,16 @@ export class SwaggerAddon<T>
       }
     });
 
-    const documentBuild: Omit<OpenAPIObject, "paths"> = documentBuilder.build();
+    const documentBuild: Omit<OpenAPIObject, 'paths'> = documentBuilder.build();
 
     const documentFactory = (): OpenAPIObject =>
       SwaggerModule.createDocument(application, documentBuild);
 
-    SwaggerModule.setup("/swagger", application, documentFactory, {
+    SwaggerModule.setup('/swagger', application, documentFactory, {
       customSiteTitle: title,
-      jsonDocumentUrl: "/swagger/json",
+      jsonDocumentUrl: '/swagger/json',
     });
+
+    this.logger.log('Swagger initialized');
   }
-}
+}

package/src/add-ons/implementations/swagger/types.ts

@@ -1 +1 @@
-export type AuthMethod = 'bearer' | 'cookie';
+export type AuthMethod = 'bearer' | 'cookie';

package/src/add-ons/index.ts

@@ -1 +1,2 @@
-export * from './add-on.wrapper'
+export * from './add-on.wrapper';
+export * from './types';

package/src/add-ons/types.ts

@@ -1,7 +1,7 @@
-import { ISentryAddOnState } from "./implementations/sentry/sentry.add-on.state.interface";
-import { ISwaggerAddOnState } from "./implementations/swagger/swagger.add-on.state.interface";
+import { ISentryAddOnState } from './implementations/sentry/sentry.add-on.state.interface';
+import { ISwaggerAddOnState } from './implementations/swagger/swagger.add-on.state.interface';
 
 export type AddOnWrapperParams = Partial<{
-    swagger: ISwaggerAddOnState;
-    sentry: ISentryAddOnState;
-}>;
+  swagger: ISwaggerAddOnState;
+  sentry: ISentryAddOnState;
+}>;

package/src/application.base.ts

@@ -1,15 +1,18 @@
-import { DynamicModule, Provider } from "@nestjs/common";
+import { DynamicModule, Provider, Module, Global } from '@nestjs/common';
 
-import { RequirementModule } from "./requirement.module";
+import { RequirementModule } from './requirement.module';
 
+@Global()
+@Module({
+  imports: [RequirementModule],
+})
 export class ApplicationBase {
-    static withProviders(providers: Provider[]): DynamicModule {
-        const providersAndExports: Provider[] = [...providers];
-        return {
-            module: this,
-            imports: [RequirementModule],
-            providers: providersAndExports,
-            exports: [...providersAndExports]
-        }
-    }
-}
+  static withProviders(providers: Provider[]): DynamicModule {
+    const providersAndExports: Provider[] = [...providers];
+    return {
+      module: this,
+      providers: providersAndExports,
+      exports: [...providersAndExports],
+    };
+  }
+}

package/src/application.factory.ts

@@ -0,0 +1,23 @@
+import { ConsoleLogger, DynamicModule, INestApplication } from '@nestjs/common';
+import { NestFactory } from '@nestjs/core';
+import { IServerProvider } from '@ask-ell/node';
+
+import { AddOnWrapper, AddOnWrapperParams } from './add-ons';
+
+type NestApplicationFactoryParams = {
+  params: AddOnWrapperParams;
+  module: DynamicModule;
+};
+
+export async function createNestApplication({
+  params,
+  module,
+}: NestApplicationFactoryParams): Promise<IServerProvider> {
+  const application: INestApplication = await NestFactory.create(module, {
+    logger: new ConsoleLogger({
+      json: true,
+    }),
+  });
+  new AddOnWrapper(params).apply(application);
+  return application;
+}

package/src/error.interceptor.ts

@@ -0,0 +1,25 @@
+import { Entity, IResult, ok } from '@ask-ell/core';
+import { CallHandler, ExecutionContext, NestInterceptor } from '@nestjs/common';
+import { catchError, Observable, throwError } from 'rxjs';
+
+type ErrorInterceptorProps = {
+  errorConvertor: (error: unknown) => unknown;
+};
+
+export class ErrorInterceptor
+  extends Entity<ErrorInterceptorProps>
+  implements NestInterceptor
+{
+  override checkStateValidity(): IResult {
+    return ok();
+  }
+
+  intercept(_: ExecutionContext, next: CallHandler): Observable<unknown> {
+    const { errorConvertor } = this.getSnapshot();
+    return next.handle().pipe(
+      catchError((error: unknown): Observable<never> => {
+        return throwError((): unknown => errorConvertor(error));
+      })
+    );
+  }
+}

package/src/index.ts

@@ -1,7 +1,8 @@
 /**
  * @module @ask-ell/back-end
  */
-export * from './add-ons';
 export * from './scripts';
+export * from './application.base';
+export * from './application.factory';
+export * from './error.interceptor';
 export * from './keyv.store.adapter.factory';
-export * from "./application.base";

package/src/keyv.store.adapter.factory.ts

@@ -1,37 +1,43 @@
-import { Injectable } from "@nestjs/common";
-import { KeyvStoreAdapter } from "keyv";
+import { Injectable } from '@nestjs/common';
+import { KeyvStoreAdapter } from 'keyv';
 import KeyvSqlite from '@keyv/sqlite';
 import KeyvPostgres from '@keyv/postgres';
-import { ILogger, MaybeUndefined } from "@ask-ell/core";
+import { ILogger, MaybeUndefined } from '@ask-ell/core';
 import { NestLogger } from '@ask-ell/nest';
-import { join } from "node:path";
-
-import { createTmpFolder, TMP_FOLDER_PATH } from "./utils";
+import { join } from 'node:path';
 
+import { createTmpFolder, TMP_FOLDER_PATH } from './utils';
 
 type CreateKeyvStoreAdapterOptions = {
-    postgresUri: MaybeUndefined<string>;
-}
+  postgresUri: MaybeUndefined<string>;
+};
 
 @Injectable()
 export class KeyvStoreAdapterFactory {
-    private logger: ILogger = NestLogger.fromClass(KeyvStoreAdapterFactory);
+  private logger: ILogger = NestLogger.fromClass(KeyvStoreAdapterFactory);
 
-    create(options: CreateKeyvStoreAdapterOptions): KeyvStoreAdapter {
-        const adapter: KeyvStoreAdapter = this.getKeyvStoreAdapter(options);
-        this.logger.log(`Connected to database with adapter "${adapter.constructor.name}"`);
-        return adapter;
-    }
+  create(options: CreateKeyvStoreAdapterOptions): KeyvStoreAdapter {
+    const adapter: KeyvStoreAdapter = this.getKeyvStoreAdapter(options);
+    this.logger.log(
+      `Connected to database with adapter "${adapter.constructor.name}"`
+    );
+    return adapter;
+  }
 
-    private getKeyvStoreAdapter({ postgresUri }: CreateKeyvStoreAdapterOptions): KeyvStoreAdapter {
-        if (!postgresUri) {
-            createTmpFolder(this.logger);
-            const localDatabaseFilePath: string = join(TMP_FOLDER_PATH, 'database.sqlite');
-            return new KeyvSqlite(localDatabaseFilePath);
-        }
-
-        return new KeyvPostgres({
-            uri: postgresUri,
-        });
+  private getKeyvStoreAdapter({
+    postgresUri,
+  }: CreateKeyvStoreAdapterOptions): KeyvStoreAdapter {
+    if (!postgresUri) {
+      createTmpFolder(this.logger);
+      const localDatabaseFilePath: string = join(
+        TMP_FOLDER_PATH,
+        'database.sqlite'
+      );
+      return new KeyvSqlite(localDatabaseFilePath);
     }
+
+    return new KeyvPostgres({
+      uri: postgresUri,
+    });
+  }
 }

package/src/requirement.module.ts

@@ -1,57 +1,59 @@
-import { Global, Module } from "@nestjs/common";
-import { ConfigModule } from "@nestjs/config";
-import { APP_FILTER, APP_GUARD, APP_INTERCEPTOR } from "@nestjs/core";
-import { ThrottlerGuard, ThrottlerModule } from "@nestjs/throttler";
-import type { ILogger } from "@ask-ell/core";
-import { NestLogger, HealthModule, ResponseFormatInterceptor, HttpExceptionFilter } from "@ask-ell/nest";
+import { Global, Module } from '@nestjs/common';
+import { ConfigModule } from '@nestjs/config';
+import { APP_FILTER, APP_GUARD, APP_INTERCEPTOR } from '@nestjs/core';
+import { ThrottlerGuard, ThrottlerModule } from '@nestjs/throttler';
+import type { ILogger } from '@ask-ell/core';
+import {
+  NestLogger,
+  HealthModule,
+  ResponseFormatInterceptor,
+  HttpExceptionFilter,
+} from '@ask-ell/nest';
 import { SentryGlobalFilter, SentryModule } from '@sentry/nestjs/setup';
 
-import { KeyvStoreAdapterFactory } from "./keyv.store.adapter.factory";
-import { dockerSecretGetter, localSecretGetter } from "./secrets";
-
+import { KeyvStoreAdapterFactory } from './keyv.store.adapter.factory';
+import { dockerSecretGetter, localSecretGetter } from './secrets';
 
 const configModuleLogger: ILogger = NestLogger.fromClass(ConfigModule);
 
 @Global()
 @Module({
-    imports: [
-        HealthModule,
-        SentryModule.forRoot(),
-        ThrottlerModule.forRoot([{
-            ttl: 60000,
-            limit: 30,
-        }]),
-        ConfigModule.forRoot({
-            isGlobal: true,
-            load: [
-                dockerSecretGetter(configModuleLogger),
-                localSecretGetter(configModuleLogger)
-            ]
-        })
-    ],
-    providers: [
-        KeyvStoreAdapterFactory,
-        {
-            provide: APP_GUARD,
-            useClass: ThrottlerGuard
-        },
-        {
-            provide: APP_INTERCEPTOR,
-            useClass: ResponseFormatInterceptor
-        },
-        {
-            provide: APP_FILTER,
-            useClass: HttpExceptionFilter
-        },
-        {
-            provide: APP_FILTER,
-            useClass: SentryGlobalFilter
-        }
-    ],
-    exports: [
-        ConfigModule,
-        SentryModule,
-        KeyvStoreAdapterFactory
-    ]
+  imports: [
+    HealthModule,
+    SentryModule.forRoot(),
+    ThrottlerModule.forRoot([
+      {
+        ttl: 60000,
+        limit: 30,
+      },
+    ]),
+    ConfigModule.forRoot({
+      isGlobal: true,
+      load: [
+        dockerSecretGetter(configModuleLogger),
+        localSecretGetter(configModuleLogger),
+      ],
+    }),
+  ],
+  providers: [
+    KeyvStoreAdapterFactory,
+    {
+      provide: APP_GUARD,
+      useClass: ThrottlerGuard,
+    },
+    {
+      provide: APP_INTERCEPTOR,
+      useClass: ResponseFormatInterceptor,
+    },
+    {
+      provide: APP_FILTER,
+      useClass: HttpExceptionFilter,
+    },
+    {
+      provide: APP_FILTER,
+      useClass: SentryGlobalFilter,
+    },
+  ],
+  exports: [ConfigModule, SentryModule, KeyvStoreAdapterFactory],
 })
-export class RequirementModule { }
+export class RequirementModule {}

package/src/scripts/index.ts

@@ -1 +1,2 @@
 export * from './move-keyv-data.script';
+export * from './update-dependencies-versions.script';

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

@@ -1,67 +1,88 @@
 import { PercentageIncrementor } from '@ask-ell/core';
-import { Client, QueryResult } from 'pg';
 import { Script, ExecuteOptions } from '@ask-ell/node';
 import { NestLogger } from '@ask-ell/nest';
+import { Client, QueryResult } from 'pg';
 
-
-type KeyvRowData = {
-    key: string;
-    value: any;
-}
+type KeyvRowData<Value = unknown> = {
+  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)
-        });
-    }
-
-    async execute({ logger, arguments: { origin, target }, prompts: { confirm } }: ExecuteOptions): Promise<void> {
-        const originPostgresClient: Client = new Client(origin);
-        const targetPostgresClient: Client = new Client(target);
+  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),
+    });
+  }
 
-        logger.log('Reading databases...');
+  async execute({
+    logger,
+    arguments: { origin, target },
+    prompts: { confirm },
+  }: ExecuteOptions): Promise<void> {
+    const originPostgresClient: Client = new Client(origin);
+    const targetPostgresClient: Client = new Client(target);
 
-        await Promise.all([
-            originPostgresClient.connect(),
-            targetPostgresClient.connect()
-        ]);
+    logger.log('Reading databases...');
 
-        try {
-            const { rows }: QueryResult<KeyvRowData> = await originPostgresClient.query('SELECT * FROM keyv');
+    await Promise.all([
+      originPostgresClient.connect(),
+      targetPostgresClient.connect(),
+    ]);
 
-            const rowsCount: number = rows.length;
-            logger.log(`You're going to insert ${rowsCount} keyv entries from the original database to the target database.`);
+    try {
+      const { rows }: QueryResult<KeyvRowData> =
+        await originPostgresClient.query('SELECT * FROM keyv');
 
-            const confirmed: boolean = await confirm('Are you sure you want to proceed?');
+      const rowsCount: number = rows.length;
+      logger.log(
+        `You're going to insert ${rowsCount} keyv entries from the original database to the target database.`
+      );
 
-            if (confirmed) {
-                logger.log('Inserting entries into the target database...');
-                const incrementor: PercentageIncrementor = new PercentageIncrementor(rowsCount);
-                incrementor.onIncrement(({ achivmentOnPercent }): void => {
-                    logger.log(`Progress: ${achivmentOnPercent}%`);
-                });
+      const confirmed: boolean = await confirm(
+        'Are you sure you want to proceed?'
+      );
 
-                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

@@ -0,0 +1,201 @@
+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 { 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');
+  }
+}
+
+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;
+};
+
+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);
+}
+
+type UpdateDependenciesVersionsScriptParams = {
+  organisationPackagePrefix: string;
+  blackListedPackages: string[];
+};
+
+type WorkspaceDependenciesMapElement = {
+  id: string;
+  dependencies: string[];
+  source: PackageContent;
+};
+
+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;
+  }
+
+  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}"`);
+    }
+
+    console.log('Package files updated.');
+  }
+
+  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);
+        }
+      }
+    }
+
+    console.log('Dependencies scan done.');
+
+    return workspaceDependenciesMap;
+  }
+
+  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 isBlackListed(packageId: string): boolean {
+    return this.blackListedPackages.includes(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/utils/tmp.ts

@@ -1,16 +1,15 @@
-import { ILogger } from "@ask-ell/core";
-import { existsSync, mkdirSync } from "node:fs";
-import { join } from "node:path";
-
+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.`);
-}
+  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.`);
+};