@ask-ell/back-end 0.0.11 → 0.1.0

package/.spec.swcrc

@@ -0,0 +1,22 @@
+{
+  "jsc": {
+    "target": "es2017",
+    "parser": {
+      "syntax": "typescript",
+      "decorators": true,
+      "dynamicImport": true
+    },
+    "transform": {
+      "decoratorMetadata": true,
+      "legacyDecorator": true
+    },
+    "keepClassNames": true,
+    "externalHelpers": true,
+    "loose": true
+  },
+  "module": {
+    "type": "es6"
+  },
+  "sourceMaps": true,
+  "exclude": []
+}

package/dist/tsconfig.lib.tsbuildinfo

@@ -0,0 +1 @@
+{"version":"6.0.3"}

package/eslint.config.mjs

@@ -0,0 +1,22 @@
+import baseConfig from '../../eslint.config.mjs';
+
+export default [
+  ...baseConfig,
+  {
+    files: ['**/*.json'],
+    rules: {
+      '@nx/dependency-checks': [
+        'error',
+        {
+          ignoredFiles: ['{projectRoot}/eslint.config.{js,cjs,mjs,ts,cts,mts}'],
+        },
+      ],
+    },
+    languageOptions: {
+      parser: await import('jsonc-eslint-parser'),
+    },
+  },
+  {
+    ignores: ['**/out-tsc'],
+  },
+];

package/jest.config.ts

@@ -0,0 +1,21 @@
+/* eslint-disable */
+import { readFileSync } from 'fs';
+
+// Reading the SWC compilation config for the spec files
+const swcJestConfig = JSON.parse(
+  readFileSync(`${__dirname}/.spec.swcrc`, 'utf-8')
+);
+
+// Disable .swcrc look-up by SWC core because we're passing in swcJestConfig ourselves
+swcJestConfig.swcrc = false;
+
+export default {
+  displayName: '@ask-ell/back-end',
+  preset: '../../jest.preset.js',
+  testEnvironment: 'node',
+  transform: {
+    '^.+\\.[tj]s$': ['@swc/jest', swcJestConfig],
+  },
+  moduleFileExtensions: ['ts', 'js', 'html'],
+  coverageDirectory: 'test-output/jest/coverage',
+};

package/package.json

@@ -1,20 +1,25 @@
 {
   "name": "@ask-ell/back-end",
-  "version": "0.0.11",
+  "version": "0.1.0",
   "private": false,
   "type": "commonjs",
   "main": "./src/index.js",
   "types": "./src/index.d.ts",
   "dependencies": {
-    "keyv": "^5.6.0",
-    "@keyv/postgres": "^2.2.3",
-    "@keyv/sqlite": "^4.0.8",
-    "@nestjs/common": "^11.1.7",
-    "pg": "^8.22.0",
-    "@sentry/nestjs": "^10.47.0",
-    "@ask-ell/nest": "^0.0.12",
-    "@ask-ell/ask": "^0.0.5",
-    "@ask-ell/node": "^0.0.2",
-    "@ask-ell/core": "^1.3.1"
+    "@ask-ell/core": "*",
+    "@ask-ell/node": "*",
+    "@ask-ell/nest": "*",
+    "@keyv/postgres": "*",
+    "@keyv/sqlite": "*",
+    "@nestjs/common": "*",
+    "@nestjs/config": "*",
+    "@nestjs/core": "*",
+    "@nestjs/swagger": "*",
+    "@nestjs/throttler": "*",
+    "@sentry/nestjs": "*",
+    "helmet": "*",
+    "keyv": "*",
+    "pg": "*",
+    "tslib": "*"
   }
 }

package/project.json

@@ -0,0 +1,29 @@
+{
+  "name": "back-end",
+  "$schema": "../../node_modules/nx/schemas/project-schema.json",
+  "sourceRoot": "packages/back-end/src",
+  "projectType": "library",
+  "tags": [],
+  "targets": {
+    "build": {
+      "executor": "@nx/js:tsc",
+      "dependsOn": ["^build"],
+      "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"
+        ]
+      }
+    },
+    "test": {
+      "options": {
+        "passWithNoTests": true
+      }
+    }
+  }
+}

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

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

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

@@ -0,0 +1,36 @@
+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/security/security.add-on.ts

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

package/src/add-ons/implementations/sentry/{sentry.add-on.interface.d.ts → sentry.add-on.interface.ts}

@@ -1,6 +1,8 @@
 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> {
-}
-//# sourceMappingURL=sentry.add-on.interface.d.ts.map
+
+
+export interface ISentryAddOn<T>
+  extends IEntity<ISentryAddOnState>, IAddOn<T> { }

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

@@ -0,0 +1,5 @@
+export interface ISentryAddOnState {
+  publicKey: string;
+  host: string;
+  projectId: string;
+}

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

@@ -0,0 +1,25 @@
+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> {
+    return ok();
+  }
+
+  apply(): void {
+    const { host, projectId, publicKey } = this.getSnapshot();
+
+    new NestSentryConfiguration({
+        publicKey,
+        host,
+        projectId
+    }).init();
+  }
+}

package/src/add-ons/implementations/swagger/{swagger.add-on.interface.d.ts → swagger.add-on.interface.ts}

@@ -1,6 +1,7 @@
 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> {
-}
-//# sourceMappingURL=swagger.add-on.interface.d.ts.map
+
+export interface ISwaggerAddOn<T>
+  extends IEntity<ISwaggerAddOnState>, IAddOn<T> { }

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

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

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

@@ -0,0 +1,43 @@
+import { Entity, type IResult, ok } from "@ask-ell/core";
+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";
+
+
+export class SwaggerAddon<T>
+  extends Entity<ISwaggerAddOnState>
+  implements ISwaggerAddOn<T>
+{
+  checkStateValidity(_newState: ISwaggerAddOnState): IResult<void> {
+    return ok();
+  }
+
+  apply(application: INestApplication<T>): void {
+    const { title, auths } = this.getSnapshot();
+
+    const documentBuilder: DocumentBuilder = new DocumentBuilder().setTitle(title)
+
+    auths?.forEach((auth: AuthMethod): void => {
+      if (auth === 'bearer') {
+        documentBuilder.addBearerAuth();
+      }
+    });
+
+    const documentBuild: Omit<OpenAPIObject, "paths"> = documentBuilder.build();
+
+    const documentFactory = (): OpenAPIObject =>
+      SwaggerModule.createDocument(application, documentBuild);
+
+    SwaggerModule.setup("/swagger", application, documentFactory, {
+      customSiteTitle: title,
+      jsonDocumentUrl: "/swagger/json",
+    });
+  }
+}

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

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

package/src/add-ons/index.ts

@@ -0,0 +1 @@
+export * from './add-on.wrapper'

package/src/add-ons/{types.d.ts → 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";
+
 export type AddOnWrapperParams = Partial<{
     swagger: ISwaggerAddOnState;
     sentry: ISentryAddOnState;
-}>;
-//# sourceMappingURL=types.d.ts.map
+}>;

package/src/application.base.ts

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

package/src/{index.d.ts → index.ts}

@@ -1,5 +1,7 @@
+/**
+ * @module @ask-ell/back-end
+ */
 export * from './add-ons';
 export * from './scripts';
 export * from './keyv.store.adapter.factory';
 export * from "./application.base";
-//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,37 @@
+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 { NestLogger } from '@ask-ell/nest';
+import { join } from "node:path";
+
+import { createTmpFolder, TMP_FOLDER_PATH } from "./utils";
+
+
+type CreateKeyvStoreAdapterOptions = {
+    postgresUri: MaybeUndefined<string>;
+}
+
+@Injectable()
+export class 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;
+    }
+
+    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

@@ -0,0 +1,57 @@
+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";
+
+
+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
+    ]
+})
+export class RequirementModule { }

package/src/scripts/{index.d.ts → index.ts}

@@ -1,2 +1 @@
 export * from './move-keyv-data.script';
-//# sourceMappingURL=index.d.ts.map

package/src/scripts/{move-keyv-data.script.js → move-keyv-data.script.ts}

@@ -1,55 +1,67 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MoveKeyvDataScript = void 0;
-const core_1 = require("@ask-ell/core");
-const pg_1 = require("pg");
-const node_1 = require("@ask-ell/node");
-const nest_1 = require("@ask-ell/nest");
-class MoveKeyvDataScript extends node_1.Script {
+import { PercentageIncrementor } from '@ask-ell/core';
+import { Client, QueryResult } from 'pg';
+import { Script, ExecuteOptions } from '@ask-ell/node';
+import { NestLogger } from '@ask-ell/nest';
+
+
+type KeyvRowData = {
+    key: string;
+    value: any;
+}
+
+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: nest_1.NestLogger.fromClass(MoveKeyvDataScript)
+            logger: NestLogger.fromClass(MoveKeyvDataScript)
         });
     }
-    async execute({ logger, arguments: { origin, target }, prompts: { confirm } }) {
-        const originPostgresClient = new pg_1.Client(origin);
-        const targetPostgresClient = new pg_1.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...');
+
         await Promise.all([
             originPostgresClient.connect(),
             targetPostgresClient.connect()
         ]);
+
         try {
-            const { rows } = await originPostgresClient.query('SELECT * FROM keyv');
-            const rowsCount = rows.length;
+            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 confirmed = 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 = new core_1.PercentageIncrementor(rowsCount);
-                incrementor.onIncrement(({ achivmentOnPercent }) => {
+                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();
                 }
+
                 logger.log(`${rowsCount} entries inserted into the target database.`);
                 logger.log('Migration completed successfully.');
-            }
-            else {
+            } else {
                 logger.log('Migration cancelled.');
             }
-        }
-        finally {
-            await originPostgresClient.end();
-            await targetPostgresClient.end();
+        } finally {
+            await Promise.all([
+                originPostgresClient.end(),
+                targetPostgresClient.end()
+            ]);
             logger.log('Database connections closed.');
         }
     }
 }
-exports.MoveKeyvDataScript = MoveKeyvDataScript;

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

@@ -0,0 +1,8 @@
+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.')

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

@@ -0,0 +1,24 @@
+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 => {
+    const isDirectoryExists: boolean = existsSync(rootDirectoryPath);
+    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;
+        }, {});
+}

package/src/secrets/index.ts

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

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

@@ -0,0 +1,8 @@
+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.');

package/src/secrets/types.ts

@@ -0,0 +1 @@
+export type SecretGetter = () => object;

package/src/utils/index.ts

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

package/src/utils/tmp.ts

@@ -0,0 +1,16 @@
+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/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "files": [],
+  "include": [],
+  "references": [
+    {
+      "path": "./tsconfig.lib.json"
+    },
+    {
+      "path": "./tsconfig.spec.json"
+    }
+  ],
+  "compilerOptions": {
+    "ignoreDeprecations": "6.0"
+  }
+}

package/tsconfig.lib.json

@@ -0,0 +1,18 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "baseUrl": ".",
+    "rootDir": "src",
+    "outDir": "dist",
+    "tsBuildInfoFile": "dist/tsconfig.lib.tsbuildinfo",
+    "emitDeclarationOnly": false,
+    "module": "nodenext",
+    "moduleResolution": "nodenext",
+    "forceConsistentCasingInFileNames": true,
+    "types": ["node"],
+    "ignoreDeprecations": "6.0"
+  },
+  "include": ["src/**/*.ts"],
+  "references": [],
+  "exclude": ["jest.config.ts", "src/**/*.spec.ts", "src/**/*.test.ts"]
+}