skyeye-svc-common-utils 2.0.0-dev0.2 → 2.0.0-dev0.21

package/src/utils/baseClass/appDataSource.ts

@@ -0,0 +1,23 @@
+import { DataSource, DataSourceOptions } from 'typeorm';
+import { logger } from '../logger/logger';
+
+export class AppDataSource {
+
+    private static instance: DataSource;
+
+    private constructor() {}
+
+    public static getInstance() {
+        return AppDataSource.instance;
+    }
+
+    public static async startConnection(options: DataSourceOptions) {
+        if (!AppDataSource.instance) {
+            AppDataSource.instance = new DataSource(options);
+        }
+
+        if (!AppDataSource.instance.isInitialized) {
+            await AppDataSource.instance.initialize();
+        }
+    }
+}

package/src/utils/baseClass/baseController.ts

@@ -7,7 +7,7 @@ import { QueryRunner } from 'typeorm';
 import { commonAppConst } from '../appConst';
 import { commonAppConfig } from '../appConfig';
 import { Mutex } from 'async-mutex';
-import { getDataSource } from './dataSourceManager';
+import { AppDataSource } from './appDataSource';
 
 
 export abstract class BaseController {
@@ -18,8 +18,8 @@ export abstract class BaseController {
         let queryRunner: QueryRunner;
 
         try {
-            const connection = getDataSource();
-            queryRunner = connection.createQueryRunner();
+            // Use queryRunner if transaction is needed
+            queryRunner = AppDataSource.getInstance().createQueryRunner();
             await queryRunner.startTransaction();
 
             return Promise.resolve(queryRunner);
@@ -59,12 +59,12 @@ export abstract class BaseController {
         } catch (err) {
             logger.error(`BaseController/endTransaction: ${err}`);
         } finally {
-            if (!baseControllerParameter.queryRunner.isReleased) {
-                try {
-                    await baseControllerParameter.queryRunner.release();
-                } catch (err) {
-                    logger.error(`BaseController/endTransaction Release Error: ${err}`);
+            try {
+                if (!baseControllerParameter.queryRunner.isReleased) {
+                        await baseControllerParameter.queryRunner.release();
                 }
+            } catch (err) {
+                logger.error(`BaseController/endTransaction Release Error: ${err}`);
             }
         }
     }
@@ -149,7 +149,7 @@ export abstract class BaseController {
                     baseControllerParameter.serviceResponse.isSuccess = false;
                     baseControllerParameter.serviceResponse.error = true;
                     baseControllerParameter.serviceResponse.message = err.message;
-
+                    
                     throw err;
                 });
             }

package/src/utils/index.ts

@@ -0,0 +1,2 @@
+export * from './appConfig';
+export * from './appConst';

package/src/utils/logger/morganLogger.ts

@@ -7,7 +7,7 @@ import dateformat from 'dateformat';
 // ensure log directory exists
 fs.existsSync(commonAppConfig.LogPath) || fs.mkdirSync(commonAppConfig.LogPath)
  
-function FileNameGenerator(time:Date, index:number){
+const FileNameGenerator = (time: number | Date, index: number) =>{
     if (!time)
     {
         time = new Date();
@@ -18,7 +18,7 @@ function FileNameGenerator(time:Date, index:number){
 }
 
 // create a rotating write stream
-var accessLogStream = rfs(FileNameGenerator, {
+var accessLogStream = rfs.createStream(FileNameGenerator, {
   interval: '1d', // rotate daily
   path: commonAppConfig.LogPath
 })

package/src/utils/middleware/loadConfig.ts

@@ -0,0 +1,150 @@
+import dotenv from 'dotenv';
+import { getKeyVault } from '../../lib';
+import { logger } from '../logger/logger';
+import { z } from 'zod';
+import { zEnvironment, Environment } from '../appConst';
+
+/**
+ * @description
+ * @property {string} appName - service's app name from package.json
+ * @property {string} version - service's version from package.json
+ * @property {enum} environment - current environment
+ * @property {string} keyVaultName - Azure key vault name
+ * @property {string} keyVaultSecretName - secret name of Azure key vault
+ * @todo migration to single typedef
+ */
+const zEnvFileAppConfig = z.object({
+    appName: z.string(),
+    version: z.string(),
+    environment: zEnvironment,
+    keyVaultName: z.string(),
+    keyVaultSecretName: z.string()
+}).strict();
+
+/**
+ * @description typedef of environment File App Config
+ */
+type EnvFileAppConfig = z.infer<typeof zEnvFileAppConfig>;
+
+/**
+ * @todo migration to single typedef
+ */
+const zElasticKeyVault = z.object({
+    secretToken: z.string(),
+    serverUrl: z.string()
+})
+
+/**
+ * @todo migration to single typedef
+ */
+const zTeamsChannelWebHook = z.object({
+    errorChannel: z.string(),
+    warnChannel: z.string()
+})
+
+/**
+ * @todo migration to single typedef
+ */
+const zTelemetry = z.object({
+    teamsChannelWebHook: zTeamsChannelWebHook,
+    elasticKeyVault: zElasticKeyVault
+})
+
+/**
+ * @todo migration to single typedef
+ */
+ const zSecretFileAppConfig = z.object({
+    telemetry: zTelemetry,
+    serviceConfig: z.any().nullable()
+});
+
+/**
+ * @description typedef of secret file
+ */
+type SecretFileAppConfig = z.infer<typeof zSecretFileAppConfig>;
+
+/**
+ * @todo migration to single typedef
+ */
+type AppConfig = EnvFileAppConfig & SecretFileAppConfig;
+
+/**
+ * @description configuration carrier (or, instance). We can classified all the configurations into 2 categories:
+ *  - Environment File App Config: configuration from the environment file (.env) and some other settings
+ *  - Secret File App Config: loaded from the Azure Key Vault
+ */
+export let appConfig: AppConfig;
+
+/**
+ * @todo move to loadConfig since all the environment fields should be loaded from appConfig
+ */
+export const environment: Environment = (process.env.NODE_ENV as Environment) ?? 'development';
+
+/**
+ * @description preload for app configuration, once it is been called, the appConfig will be loaded and be freezed
+ * @param packagePath - optional, path of `package.json` in order to load app name and version
+ */
+export const loadConfig = async (packagePath?: string) => {
+    logger.verbose('start /appConfig/preload()');
+
+    // load environment file
+    dotenv.config({ path: `${environment}.env` });
+
+    /**
+     * To load the appName and the version, we read the package information in the following order:
+     * 1. check if the environment value is defined directly
+     * 2. check if environment given from npm is defined
+     * 3. check if value in package.json is defined
+     */
+    const pkg = require(packagePath ?? `${process.env.PWD}/package.json`);
+
+    const appName: string = ((): string => {
+        if (!!process.env.APP_NAME) { return process.env.APP_NAME; }
+        if (!!process.env.npm_package_name) { return process.env.npm_package_name; }
+        if (!!pkg.name) { return pkg.name; }
+        return 'default-app-name';
+    })();
+    
+    const version: string = ((): string => {
+        if (!!process.env.VERSION) { return process.env.VERSION; }
+        if (!!process.env.npm_package_version) { return process.env.npm_package_version; }
+        if (!!pkg.version) { return pkg.version; }
+        return '0.0.0';
+    })();
+
+    /**
+     * check the env which suppose to be hide as possible as it can, 
+     * which is not allowed to define in-memory.
+     */
+    if (process.env.AZURE_TENANT_ID === undefined || process.env.AZURE_CLIENT_ID === undefined || process.env.AZURE_CLIENT_SECRET === undefined) {
+        throw new Error('/appConfig/preload: missing Azure configuration');
+    }
+
+    const envFileAppConfig: EnvFileAppConfig = {
+        appName,
+        version,
+        environment,
+        keyVaultName: process.env.KEYVAULT_NAME,
+        keyVaultSecretName: process.env.LIBRARY_KEY_VAULT_SECRET_NAME
+    };
+
+    // check envFileAppConfig
+    const envTypeCheck = zEnvFileAppConfig.safeParse(envFileAppConfig);
+    if (!envTypeCheck.success) {
+        throw new Error('/appConfig/preload: invalid schema of envFileAppConfig');
+    }
+
+    // check secretFileAppConfig
+    const rawSecretResp = await getKeyVault(envFileAppConfig.keyVaultName, envFileAppConfig.keyVaultSecretName);
+    if (!rawSecretResp.isSuccess) { throw new Error(rawSecretResp.message); }
+    const secretFileAppConfig: SecretFileAppConfig = rawSecretResp.data;
+    const secretFileTypeCheck = zSecretFileAppConfig.safeParse(secretFileAppConfig);
+    if (!secretFileTypeCheck.success) {
+        throw new Error('/appConfig/preload: invalid schema of secretFileAppConfig');
+    }
+
+    appConfig = { ...envFileAppConfig, ...secretFileAppConfig };
+    Object.freeze(appConfig);
+
+    logger.verbose('end /appConfig/preload()');
+};

package/.env

@@ -1,3 +0,0 @@
-PUBLIC_JWT_SECRET=unittest
-USER_PUBLIC_RETRIEVE = usersvc
-USER_INTERNAL_RETRIEVE = usersvc

package/dist/utils/baseClass/dataSourceManager.d.ts

@@ -1,11 +0,0 @@
-import { DataSource, DataSourceOptions } from 'typeorm';
-export declare class DataSourceManager {
-    private static instance;
-    private dataSources;
-    private constructor();
-    static getInstance(): DataSourceManager;
-    createDataSource(name: string, options?: DataSourceOptions): Promise<DataSource>;
-    getDataSource(dataSourceName: string): DataSource;
-}
-export declare function getDataSource(dataSourceName?: string): DataSource;
-export declare function createDataSource(options?: DataSourceOptions, name?: string): Promise<DataSource>;

package/dist/utils/baseClass/dataSourceManager.js

@@ -1,54 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createDataSource = exports.getDataSource = exports.DataSourceManager = void 0;
-const typeorm_1 = require("typeorm");
-// to be used instead of getConnectionManager()
-class DataSourceManager {
-    constructor() {
-        this.dataSources = new Map();
-    }
-    static getInstance() {
-        if (!DataSourceManager.instance) {
-            DataSourceManager.instance = new DataSourceManager();
-        }
-        return DataSourceManager.instance;
-    }
-    createDataSource(name, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const _options = options;
-            return new Promise((resolve, reject) => {
-                new typeorm_1.DataSource(_options).initialize()
-                    .then((dataSource) => {
-                    this.dataSources.set(name, dataSource).get(name);
-                    resolve(dataSource);
-                })
-                    .catch((e) => {
-                    reject(e);
-                });
-            });
-        });
-    }
-    getDataSource(dataSourceName) {
-        return this.dataSources.get(dataSourceName || 'default');
-    }
-}
-exports.DataSourceManager = DataSourceManager;
-// to be used instead of getConnection()
-function getDataSource(dataSourceName) {
-    return DataSourceManager.getInstance().getDataSource(dataSourceName || 'default');
-}
-exports.getDataSource = getDataSource;
-function createDataSource(options, name = 'default') {
-    return DataSourceManager.getInstance().createDataSource(name, options);
-}
-exports.createDataSource = createDataSource;
-//# sourceMappingURL=dataSourceManager.js.map

package/dist/utils/baseClass/dataSourceManager.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"dataSourceManager.js","sourceRoot":"","sources":["../../../src/utils/baseClass/dataSourceManager.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,qCAAiG;AAEjG,+CAA+C;AAC/C,MAAa,iBAAiB;IAI1B;QAFQ,gBAAW,GAA4B,IAAI,GAAG,EAAE,CAAC;IAElC,CAAC;IAEjB,MAAM,CAAC,WAAW;QACrB,IAAI,CAAC,iBAAiB,CAAC,QAAQ,EAAE,CAAC;YAClC,iBAAiB,CAAC,QAAQ,GAAG,IAAI,iBAAiB,EAAE,CAAC;QACrD,CAAC;QACD,OAAO,iBAAiB,CAAC,QAAQ,CAAC;IACtC,CAAC;IAEY,gBAAgB,CAAC,IAAY,EAAE,OAA2B;;YACnE,MAAM,QAAQ,GAAG,OAAO,CAAC;YACzB,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;gBACnC,IAAI,oBAAU,CAAC,QAAQ,CAAC,CAAC,UAAU,EAAE;qBACpC,IAAI,CAAC,CAAC,UAAsB,EAAE,EAAE;oBAC7B,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;oBACjD,OAAO,CAAC,UAAU,CAAC,CAAC;gBACxB,CAAC,CAAC;qBACD,KAAK,CAAC,CAAC,CAAM,EAAE,EAAE;oBACd,MAAM,CAAC,CAAC,CAAC,CAAC;gBACd,CAAC,CAAC,CAAA;YACN,CAAC,CAAC,CAAC;QACP,CAAC;KAAA;IAEM,aAAa,CAAC,cAAsB;QACvC,OAAO,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,cAAc,IAAI,SAAS,CAAC,CAAC;IAC7D,CAAC;CAEJ;AA/BD,8CA+BC;AAED,wCAAwC;AACxC,SAAgB,aAAa,CAAC,cAAuB;IACjD,OAAO,iBAAiB,CAAC,WAAW,EAAE,CAAC,aAAa,CAAC,cAAc,IAAI,SAAS,CAAC,CAAC;AACtF,CAAC;AAFD,sCAEC;AAED,SAAgB,gBAAgB,CAAC,OAA2B,EAAE,OAAe,SAAS;IAClF,OAAO,iBAAiB,CAAC,WAAW,EAAE,CAAC,gBAAgB,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;AAC3E,CAAC;AAFD,4CAEC"}

package/dist/utils/middleware/startdbConnection.d.ts

@@ -1 +0,0 @@
-export declare function startConnection(entities: any[]): Promise<void>;

package/dist/utils/middleware/startdbConnection.js

@@ -1,30 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.startConnection = void 0;
-const typeorm_1 = require("typeorm");
-const dataSourceManager_1 = require("../baseClass/dataSourceManager");
-const appConfig_1 = require("../appConfig");
-const azureKeyVault_1 = require("../../lib/azure/azureKeyVault");
-const logger_1 = require("../logger/logger");
-function startConnection(entities) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const options = Object.assign(Object.assign({}, JSON.parse(yield (0, azureKeyVault_1.getKey)(appConfig_1.commonAppConfig.SqlConnectionConfigKey))), { synchronize: false, entities: entities });
-        const myDataSource = new typeorm_1.DataSource(options);
-        if (appConfig_1.commonAppConfig.SqlEnable) {
-            (0, dataSourceManager_1.createDataSource)(options).then(() => {
-                logger_1.logger.info("TypeORM connected");
-            }).catch(error => logger_1.logger.info("TypeORM connection error: ", error));
-        }
-    });
-}
-exports.startConnection = startConnection;
-//# sourceMappingURL=startdbConnection.js.map

package/dist/utils/middleware/startdbConnection.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"startdbConnection.js","sourceRoot":"","sources":["../../../src/utils/middleware/startdbConnection.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,qCAAwD;AACxD,sEAAkE;AAClE,4CAA+C;AAC/C,iEAAuD;AACvD,6CAA0C;AAE1C,SAAsB,eAAe,CAAC,QAAe;;QACjD,MAAM,OAAO,mCAEN,IAAI,CAAC,KAAK,CAAC,MAAM,IAAA,sBAAM,EAAC,2BAAe,CAAC,sBAAsB,CAAC,CAAC,KACnE,WAAW,EAAE,KAAK,EAClB,QAAQ,EAAE,QAAQ,GACrB,CAAC;QACF,MAAM,YAAY,GAAG,IAAI,oBAAU,CAAC,OAAO,CAAC,CAAC;QAC7C,IAAI,2BAAe,CAAC,SAAS,EAAE,CAAC;YAC5B,IAAA,oCAAgB,EAAC,OAAO,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE;gBAChC,eAAM,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC;YACrC,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,CAAC,eAAM,CAAC,IAAI,CAAC,4BAA4B,EAAE,KAAK,CAAC,CAAC,CAAC;QACxE,CAAC;IACL,CAAC;CAAA;AAbD,0CAaC"}

package/src/utils/baseClass/dataSourceManager.ts

@@ -1,44 +0,0 @@
-import { DataSource, DataSourceOptions, EntityTarget, ObjectLiteral, Repository } from 'typeorm';
-
-// to be used instead of getConnectionManager()
-export class DataSourceManager {
-    private static instance: DataSourceManager;
-    private dataSources: Map<string, DataSource> = new Map();
-    
-    private constructor() {}
-    
-    public static getInstance(): DataSourceManager {
-        if (!DataSourceManager.instance) {
-        DataSourceManager.instance = new DataSourceManager();
-        }
-        return DataSourceManager.instance;
-    }
-
-    public async createDataSource(name: string, options?: DataSourceOptions): Promise<DataSource> {
-        const _options = options;
-        return new Promise((resolve, reject) => {
-            new DataSource(_options).initialize()
-            .then((dataSource: DataSource) => {
-                this.dataSources.set(name, dataSource).get(name);
-                resolve(dataSource);
-            })
-            .catch((e: any) => {
-                reject(e);
-            })
-        });
-    }
-
-    public getDataSource(dataSourceName: string): DataSource {
-        return this.dataSources.get(dataSourceName || 'default');
-    }
-    
-}
-
-// to be used instead of getConnection()
-export function getDataSource(dataSourceName?: string): DataSource {
-    return DataSourceManager.getInstance().getDataSource(dataSourceName || 'default');
-}
-
-export function createDataSource(options?: DataSourceOptions, name: string = 'default') {
-    return DataSourceManager.getInstance().createDataSource(name, options);
-}

package/src/utils/middleware/startdbConnection.ts

@@ -1,20 +0,0 @@
-import { DataSourceOptions, DataSource } from 'typeorm';
-import { createDataSource } from '../baseClass/dataSourceManager';
-import { commonAppConfig } from '../appConfig';
-import { getKey } from '../../lib/azure/azureKeyVault';
-import { logger } from '../logger/logger';
-
-export async function startConnection(entities: any[]) {
-    const options: DataSourceOptions =
-    {
-        ...JSON.parse(await getKey(commonAppConfig.SqlConnectionConfigKey)),
-        synchronize: false,
-        entities: entities
-    };
-    const myDataSource = new DataSource(options);
-    if (commonAppConfig.SqlEnable) {
-        createDataSource(options).then(() => {
-            logger.info("TypeORM connected");
-        }).catch(error => logger.info("TypeORM connection error: ", error));
-    }
-}