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

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "skyeye-svc-common-utils",
-  "version": "2.0.0-dev0.2",
+  "version": "2.0.0-dev0.20",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {
     "build": "tsc -p ./tsconfig.json",
-    "clean": "rm -rf node_modules log",
+    "clean": "rm -rf node_modules package-lock.json dist log",
     "cleanPublish": "npm i && npm run build && npm run clean && npm publish"
   },
   "repository": {
@@ -21,20 +21,14 @@
   "homepage": "https://github.com/HandshakesByDC/SkyEye-SVC-Common-Utils#readme",
   "dependencies": {
     "@azure/data-tables": "^13.2.2",
-    "@azure/identity": "latest",
-    "@azure/keyvault-secrets": "latest",
-    "@azure/service-bus": "7.9.1",
+    "@azure/identity": "^4.0.1",
+    "@azure/keyvault-secrets": "^4.8.0",
+    "@azure/service-bus": "^7.9.4",
     "@azure/storage-blob": "^12.1.2",
     "@azure/storage-queue": "^12.0.2",
+    "@azure/search-documents": "11.2.1",
+    "@azure/abort-controller": "1.0.4",
     "@sendgrid/mail": "^7.7.0",
-    "@types/chai": "^4.2.11",
-    "@types/express": "4.17.14",
-    "@types/express-serve-static-core": "4.17.30",
-    "@types/google-protobuf": "^3.7.2",
-    "@types/jsonwebtoken": "^9.0.0",
-    "@types/lodash": "4.14.182",
-    "@types/swagger-jsdoc": "^3.0.2",
-    "@types/swagger-ui-express": "^4.1.1",
     "async-mutex": "^0.3.2",
     "cron-parser": "4.8.1",
     "dateformat": "^3.0.3",
@@ -45,30 +39,39 @@
     "http-errors": "^1.7.3",
     "https": "^1.0.0",
     "ioredis": "^5.0.4",
-    "jsonwebtoken": "^9.0.0",
+    "jsonwebtoken": "^9.0.2",
+    "lodash": "^4.17.21",
     "logform": "2.4.2",
     "moment": "^2.24.0",
     "morgan": "^1.9.1",
     "node-fetch": "^2.6.0",
     "nyc": "^15.1.0",
-    "rotating-file-stream": "^1.4.6",
+    "rotating-file-stream": "^3.2.1",
     "skyeye-common-const": "1.0.42",
     "swagger-jsdoc": "^3.5.0",
     "swagger-ui-express": "^4.1.3",
     "ts-node": "^10.7.0",
     "typeorm": "^0.3.17",
     "typescript": "^5.3.3",
-    "uuid": "^3.3.3",
     "winston": "^3.2.1",
-    "winston-daily-rotate-file": "^4.2.1"
+    "winston-daily-rotate-file": "^4.2.1",
+    "abort-controller": "3.0.0",
+    "zod": "3.22.3"
   },
   "devDependencies": {
-    "@types/dateformat": "^3.0.1",
-    "@types/debug": "~4.1.5",
-    "@types/http-errors": "~1.6.1",
-    "@types/morgan": "~1.7.37",
-    "@types/node": "^14.0.27",
-    "@types/node-fetch": "^2.5.3",
-    "@types/uuid": "^3.4.6"
+    "@types/dateformat": "^5.0.2",
+    "@types/debug": "^4.1.12",
+    "@types/http-errors": "~2.0.4",
+    "@types/morgan": "~1.9.9",
+    "@types/node": "^20.11.19",
+    "@types/node-fetch": "^2.6.11",
+    "@types/chai": "^4.3.11",
+    "@types/express": "^4.17.21",
+    "@types/express-serve-static-core": "^4.17.43",
+    "@types/google-protobuf": "^3.15.12",
+    "@types/jsonwebtoken": "^9.0.6",
+    "@types/lodash": "^4.14.202",
+    "@types/swagger-jsdoc": "^6.0.4",
+    "@types/swagger-ui-express": "^4.1.6"
   }
 }

package/src/index.ts

@@ -7,23 +7,26 @@ export * from './utils/logger/morganLogger';
 export * from './utils/middleware/handleError';
 export * from './utils/middleware/isPublicUser';
 export * from './utils/middleware/overwriteConst';
-export * from './utils/middleware/startdbConnection';
+export * from './utils/middleware/loadConfig';
 export * from './utils/baseClass/baseController';
 export * from './utils/baseClass/baseService';
-export * from './interfaces/index';
+export * from './utils/baseClass/appDataSource';
+export * from './utils/monitoring/apm';
+export * from './utils/commonUtils/appConfigKeyRetriever';
+export * from './utils/documentation/swagger';
 export * from './lib/azure/azureKeyVault';
 export * from './lib/azure/azureServiceBusClient';
 export * from './lib/azure/azureStorageQueue';
 export * from './lib/azure/azureServiceBusQueue';
 export * from './lib/azure/azureTableStorage';
 export * from './lib/azure/azureBlobStorage';
-export * from './utils/documentation/swagger';
+export * from './lib/azure/cognitiveSearch';
+export * from './lib/fetch';
 export * from './lib/httpClient';
-export * from './utils/monitoring/apm';
-export * from './models/baseControllerParameter';
-export * from './models';
 export * from './lib/redisClient';
 export * from './lib/sendGridClient';
+export * from './models';
+export * from './models/baseControllerParameter';
+export * from './interfaces';
 export * from './interfaces/grpcServiceResponse';
 export * from './interfaces/grpcListRequest';
-export * from './utils/commonUtils/appConfigKeyRetriever';

package/src/lib/azure/azureKeyVault.ts

@@ -1,6 +1,9 @@
 import { SecretClient } from "@azure/keyvault-secrets";
 import { DefaultAzureCredential } from "@azure/identity";
+import { AbortController } from '@azure/abort-controller';
 import { commonAppConfig} from '../../utils/appConfig';
+import { thirdPartyRegulation } from '../../utils/appConst';
+import { ServiceResponse } from '../../interfaces';
 
 export async function getKey(secretName : string) : Promise<string>{
     const credential = new DefaultAzureCredential();
@@ -12,4 +15,45 @@ export async function getKey(secretName : string) : Promise<string>{
     const secret = await client.getSecret(secretName);
 
     return secret.value;
+}
+
+/**
+ * @description To retrieve secret from a given Azure Key Vault
+ * @param {string} keyVaultName - name of Azure Key Vault
+ * @param {string} secretName - secret name of Azure Key Vault
+ * @param {number} abortWithinMsec - automatically abort within given millisecond
+ * @param {number} retry - automatically retry with given times
+ * @returns {ServiceResponse}
+ */
+export async function getKeyVault(
+    keyVaultName: string,
+    secretName : string,
+    abortWithinMsec: number = thirdPartyRegulation.requestLimitationMsec,
+    retry: number = thirdPartyRegulation.requestDefaultRetry
+): Promise<ServiceResponse> {
+    const resp: ServiceResponse = { isSuccess: false };
+
+    try {
+        const credential = new DefaultAzureCredential();
+        const url = `https://${keyVaultName}.vault.azure.net`;
+        const client = new SecretClient(url, credential);
+
+        let curTry = 0;
+        while (curTry <= retry) {
+            const signal = AbortController.timeout(abortWithinMsec);
+            const secret = await client.getSecret(secretName, { abortSignal: signal });
+            if (secret && secret.value) {
+                resp.data = JSON.parse(secret.value);
+                resp.isSuccess = true;
+                break;
+            }
+            if (curTry === retry) {
+                throw new Error(`/keyVault/getKeyVault(): failed fetch secret with retries (${retry})`);
+            }
+        }
+    } catch (err) {
+        resp.message = err as string;
+    }
+
+    return resp;
 }

package/src/lib/azure/cognitiveSearch/QueryType.ts

@@ -0,0 +1,8 @@
+/**
+ * @description Specifies whether simple or full of query type must be matched
+ * @see https://docs.microsoft.com/en-us/rest/api/searchservice/search-documents
+ */
+export enum QueryType {
+    simple = 'simple',
+    full = 'full'
+}

package/src/lib/azure/cognitiveSearch/SearchClient.ts

@@ -0,0 +1,149 @@
+import { SearchClient as OfficialSearchClient, AzureKeyCredential } from '@azure/search-documents';
+import { logger } from '../../../utils/logger/logger';
+import { getKeyVault } from '../../azure/azureKeyVault';
+import { ServiceResponse } from '../../../interfaces';
+import { AzureSearchIndex, AzureSearchConfig } from '../../../utils';
+import { appConfig, loadConfig } from '../../../utils/middleware/loadConfig';
+
+
+/**
+ * @classdesc SearchClient as an adaptor to bind the third-party library
+ * (@azure/search-documents) with the internal application. That is to say, the 
+ * class is aim to enhance dev's maintenance between lib and the exact usage.
+ * @property {SearchClient} instance - Singleton instance
+ * @property {string} endpoint - Azure cognitive search's request endpoint
+ * @property {string} credential - Azure cognitive search's API key
+ * @property {Semaphore} semaphore - to ensure not too many requests are sent to Azure cognitive search
+ * @property {Record<AzureSearchIndex, string>} indexMap - to store the index's alias
+ * 
+ * @example
+ * const client = await SearchClient.getInstance();
+ * const searchOption = new SearchOption( { top: 1 });
+ * console.log(JSON.stringify(await client.query(AzureSearchIndex.company, '*', searchOption.value())));
+ */
+export class SearchClient {
+    private static instance: SearchClient;
+    private static endpoint: string;
+    private static credential: string;
+    private static indexMap: Record<AzureSearchIndex, string>;
+
+    /**
+     * @description To retrieve the instance in the Singleton pattern
+     * @returns {SearchClient} the singleton instance of SearchClient
+     */
+    static async getInstance(): Promise<SearchClient> {
+        if (!!SearchClient.instance) { return SearchClient.instance; }
+
+        SearchClient.instance = new SearchClient();
+
+        /**
+         * When the keyVaultName is empty, loadConfig() should be called in order to fetch the value as possible
+         * since we are not using lazy-loading here. It would be better to transform into a lazy-loading mechanism.
+         */
+        if (appConfig === undefined) {
+            try {
+                await loadConfig();
+                if (appConfig.keyVaultName === undefined) {
+                    throw new Error('SearchClient/getInstance: empty keyVaultName');
+                }
+            } catch (err) {
+                throw err;
+            }
+        }
+
+        const credentialResp = await getKeyVault(appConfig.keyVaultName, AzureSearchConfig.credentialSecretName);
+
+        if (credentialResp.isSuccess === false) {
+            throw new Error('/SearchClient/getInstance(): retrieve search credential failed');
+        }
+
+        const secret: { endpoint: string, credential: string } = credentialResp.data;
+
+        const indexMapResp = await getKeyVault(appConfig.keyVaultName, AzureSearchConfig.indexSecretName);
+
+        if (indexMapResp.isSuccess === false) {
+            throw new Error('/SearchClient/getInstance(): retrieve search indexMap failed');
+        }
+
+        SearchClient.indexMap = indexMapResp.data;
+        SearchClient.endpoint = secret.endpoint;
+        SearchClient.credential = secret.credential;
+        return SearchClient.instance;
+    }
+
+    /**
+     * @description To query the Azure cognitive search
+     * @param {AzureSearchIndex} index - to retrieve the document
+     * @param {string} keyword - as the prop 'search'
+     * @param {any} options - additional option for the search
+     * @param {number} retryTimes - specify how many times if Azure cognitive search returns a bad request
+     * @returns {ServiceResponse} a serviceResponse, noted that data is stated in `data.document`
+     */
+    async query(
+        index: AzureSearchIndex,
+        keyword: string = '*',
+        options?: any,
+        retryTimes: number = AzureSearchConfig.queryRetryDefault,
+        tracking: number = Math.floor(Math.random()*100000000000)
+    ): Promise<ServiceResponse> {
+        logger.verbose(`start SearchClient/query: ${tracking}`);
+        let serviceResponse: ServiceResponse = { isSuccess: false };
+        let searchResults: any;
+        let curRetry = 0;
+        try {
+
+            const client = new OfficialSearchClient(
+                SearchClient.endpoint,
+                SearchClient.indexMap[index],
+                new AzureKeyCredential(SearchClient.credential)
+            );
+
+            while (curRetry < retryTimes) {
+                try {
+                    logger.verbose(`SearchClient/query before sending : ${curRetry}|${tracking}`);
+                    searchResults = await client.search(keyword, options);
+                    logger.verbose(`SearchClient/query after sending : ${curRetry}|${tracking}`);
+                    serviceResponse.data = { document: [] };
+
+                    for await (const result of searchResults.results) {
+                        result.document.score = result.score;
+                        result.document.highlights = result.highlights;
+                        serviceResponse.data.document.push(result.document);
+                    }
+                    logger.verbose(`SearchClient/query after processing : ${curRetry}|${tracking}`);
+                    if (!!searchResults.facets) {
+                        serviceResponse.data.facets = searchResults.facets;
+                    }
+
+                    if (!!searchResults.count) {
+                        serviceResponse.data.count = searchResults.count;
+                    }
+
+                    serviceResponse.isSuccess = true;
+                } catch (err) {
+                    logger.error(`SearchClient/query: fail - ${err}`);
+                }
+
+                if (!serviceResponse.isSuccess) {
+                    logger.info(`SearchClient/query: retry - ${curRetry}`);
+                    ++curRetry;
+                    await this.sleep(AzureSearchConfig.retryIntervalSecond * 1000);
+                } else {
+                    break;
+                }
+            }
+        } catch (err) {
+            logger.error(`SearchClient/query: ${err}`);
+        }
+        logger.verbose(`end SearchClient/query : ${curRetry}|${serviceResponse.data.document.length}|${tracking}`);
+        return serviceResponse;
+    }
+
+    /**
+     * @description To postpone for specific millisecond
+     * @param {number} ms - millisecond to wait for
+     */
+    private async sleep(ms: number) {
+        await new Promise( _ => setTimeout(_, ms));
+    }
+}

package/src/lib/azure/cognitiveSearch/SearchFacets.ts

@@ -0,0 +1,16 @@
+/**
+ * @description SearchFacets as a type is to wrap facets for @azure/search-documents
+ * @see https://docs.microsoft.com/en-us/rest/api/searchservice/search-documents
+ * @property {string} attr - attribute/prop to reach
+ * @property {number} count - volume of the search
+ * @property {enum} sort - order
+ * @property {enum | number} interval - interval greater than 0 for numbers for date time values
+ * @property {string} timeoffset - specifying a dynamic set of facet entry values
+ */
+ export type SearchFacets = {
+    attr: string;
+    count?: number;
+    sort?: 'count' | '-count' | 'value' | '-value';
+    interval?: number | 'minute' | 'hour' | 'day' | 'week' | 'month' | 'quarter' | 'year';
+    timeoffset?: string;
+}

package/src/lib/azure/cognitiveSearch/SearchFilter.ts

@@ -0,0 +1,140 @@
+/**
+ * @classdesc SearchFilter is the object to construct the Filter when using Azure cognitive search
+ * @property {string} attr - the attribute, so called props, to be filtered by the condition
+ * @property {SearchFilterCondition} condition - the condition to filter, see enum @SearchFilter for more information
+ * @property {any} value - attr should under the condition with value
+ * @property {boolean} isCollection - true if the filed is defined as a collection in Azure Cognitive Search
+ * @property {'any' | 'all'} collectionOperation - collection search settings
+ * @see https://docs.microsoft.com/en-us/azure/search/search-query-understand-collection-filters
+ * 
+ * @example
+ * ```ts
+ * const primaryFilter = new SearchFilter('isPrimary', EQUAL, true);
+ * const mentionedCompanyListFilter = new SearchFilter('companyMentioned', CONTAINS, [...]);
+ * ```
+ */
+ export class SearchFilter {
+    attr: string;
+    condition: SearchFilterCondition;
+    value: any;
+    isCollection: boolean = false;
+    collectionOperation: 'any' | 'all' = 'any';
+
+    constructor(
+        attr: string,
+        condition: SearchFilterCondition,
+        value: any,
+        isCollection: boolean = false,
+        collectionOperation: 'any' | 'all' = 'any') {
+        this.attr = attr;
+        this.condition = condition;
+        this.value = value;
+        this.isCollection = isCollection;
+        this.collectionOperation = collectionOperation;
+    }
+
+    /**
+     * @description flatten is to compose the instance into a string when using Search
+     * @returns {string} the composite of the instance
+     */
+    flatten(): string {
+        if (this.isCollection) {
+            switch (this.condition) {
+                case CONTAINS:
+                    return `${this.attr}/${this.collectionOperation}(i: search.in(i,'${this.value.toString()}', ','))`;
+                case EXCLUDE:
+                    return `${this.attr}/${this.collectionOperation}(i: not search.in(i,'${this.value.toString()}', ','))`;
+                default:
+                    throw new Error(`SearchFilter/flatten: Unknown condition for collection`);
+            }
+        } else {
+            switch (this.condition) {
+                case EQUAL:
+                case NOT_EQUAL:
+                case LESS_THAN_OR_EQUAL:
+                case GREATER_THAN_OR_EQUAL:
+                    return `${this.attr} ${this.condition} ${ typeof(this.value) === 'string' ? `'${this.value}'` : this.value }`;
+                case CONTAINS:
+                    return `search.in(${this.attr}, '${this.value.toString()}', ',')`;
+                case EXCLUDE:
+                    return `${this.condition} search.in(${this.attr}, '${this.value.toString()}', ',')`;
+                default:
+                    throw new Error(`SearchFilter/flatten: Unknown condition`);
+            }
+        }
+    }
+}
+
+/**
+ * @description The condition when filtering an params.
+ */
+export enum SearchFilterCondition {
+    contains = '',
+    exclude = 'not',
+    equal = 'eq',
+    notEqual = 'ne',
+    lessThanOrEqual = 'le',
+    greaterThanOrEqual = 'ge'
+}
+
+/**
+ * @description The following const params is a easy-to-use type when implementing a SearchFilter,
+ * so that the developers no longer need to call the enum with the class reference
+ */
+export const CONTAINS = SearchFilterCondition.contains;
+export const EXCLUDE = SearchFilterCondition.exclude;
+export const EQUAL = SearchFilterCondition.equal;
+export const NOT_EQUAL = SearchFilterCondition.notEqual;
+export const LESS_THAN_OR_EQUAL = SearchFilterCondition.lessThanOrEqual;
+export const GREATER_THAN_OR_EQUAL = SearchFilterCondition.greaterThanOrEqual;
+
+/**
+ * @description describe types of combination
+ */
+export const enum CombinationType {
+    and = 'and',
+    or = 'or'
+};
+
+/**
+ * combination is a function ONLY be used for constructing two function: AND and OR,
+ * then it would be express into a string.
+ * @param {CombinationType} type - to indicate the combination type
+ * @param {Array<Array<string | SearchFilter>>} args - the arguments which need to be construct into string
+ * @returns {string} aggregation of the given args
+ */
+const combination = (type: CombinationType, ...args: Array<string | SearchFilter>): string => {
+    if (args.length === 0) { return ''; }
+     
+    function flatten(obj: string | SearchFilter): string {
+        return typeof(obj) === 'string' ? obj : obj.flatten();
+    }
+    
+    let res: string = !!args[0] ? flatten(args[0]) : '';
+
+    for (let i = 1; i < args.length; ++i) {
+        if (!!args) {
+            res += ` ${type} ${flatten(args[i])}`;
+        }
+    }
+
+    return `(${res})`;
+}
+
+/**
+ * @description AND helps developers to compose a nested filter for condition AND.
+ * @param {Array<Array<string | SearchFilter>>} args - the arguments which need to be construct into string
+ * @returns {string} aggregation of the given args
+ */
+export const AND = (...args: Array<string | SearchFilter>): string => {
+    return combination(CombinationType.and, ...args);
+}
+
+/**
+ * @description OR helps developers to compose a nested filter for condition OR.
+ * @param {Array<Array<string | SearchFilter>>} args - the arguments which need to be construct into string
+ * @returns {string} aggregation of the given args
+ */
+export const OR = (...args: Array<string | SearchFilter>): string => {
+    return combination(CombinationType.or, ...args);
+}

package/src/lib/azure/cognitiveSearch/SearchMode.ts

@@ -0,0 +1,9 @@
+/**
+ * @description Specifies whether any or all of the search terms must be matched
+ * in order to count the document as a match.
+ * @see https://docs.microsoft.com/en-us/rest/api/searchservice/search-documents
+ */
+export enum SearchMode {
+    all = 'all',
+    any = 'any'
+}

package/src/lib/azure/cognitiveSearch/SearchOption.ts

@@ -0,0 +1,155 @@
+import { AND, OR, CombinationType, SearchFilter } from './SearchFilter';
+import { SearchFacets } from './SearchFacets';
+import { SearchOrder } from './SearchOrder';
+import { SearchMode } from './SearchMode';
+import { QueryType } from './QueryType';
+
+/**
+ * @description SearchOptionType is the interface to connect with the library 
+ * @azure/search-documents, it would only be initiated when creating an instance 
+ * of class @SearchOption, none of the other functions should access this type declaration.
+ * @property {Array<string>} select - optional, to indicate the select attributes/props.
+ * @property {string | Array<string | SearchFilter>} filter - optional, search with the filter
+ * @property {CombinationType} filterCombinationType - optional, combination type of the filters
+ * @property {Array<SearchOrder>} orderBy - optional, return order
+ * @property {boolean} count - optional, if true, return with the count of the documents.
+ * @property {number} top - optional, total volume when retrieving the data
+ * @property {number} skip - optional, skip how many document
+ * @property {Array<SearchFacets>} facets - optional, retrieve data's facets
+ * @property {SearchMode} searchMode - required, different mode for search
+ */
+type SearchOptionType = {
+    select?: string[],
+    filter?: string | Array<string | SearchFilter>,
+    filterCombinationType?: CombinationType,
+    orderBy?: SearchOrder[],
+    count?: boolean,
+    top?: number,
+    skip?: number,
+    facets?: SearchFacets[],
+    searchMode?: SearchMode,
+    searchFields?: string[],
+    scoringProfile?: string,
+    highlightFields?: string,
+    highlightPreTag?: string,
+    highlightPostTag?: string,
+    queryType?: QueryType
+}
+
+/**
+ * @classdesc the class is to wrap an option when retrieving the data from
+ * @azure/search-documents/query
+ * @property searchOptionType - to store the interface of the option, noted that
+ * when calling the query, you should use SearchOption.value() instead of using
+ * this attribute.
+ */
+export class SearchOption {
+    searchOptionType?: SearchOptionType;
+
+    /**
+     * @description when initializing a SearchOption, the defaultSearchOption 
+     * will override the undefined props
+     */
+    static defaultSearchOption: SearchOptionType = {
+        count: false,
+        top: 50,
+        skip: 0,
+        searchMode: SearchMode.all,
+        filterCombinationType: CombinationType.and
+    }
+    
+    constructor(searchOptionType?: SearchOptionType) {
+        // override the default settings if the value is empty from the given OptionType
+        this.searchOptionType = { ...SearchOption.defaultSearchOption, ...searchOptionType };
+    }
+
+    /**
+     * @description to compose flatten-filter string for @azure/search-documents
+     * @returns {string} flatten-filter string
+     */
+    private composeFilter(): string {
+        if (typeof(this.searchOptionType.filter) === 'string') { return this.searchOptionType.filter; }
+        return this.searchOptionType.filterCombinationType === CombinationType.and ? 
+            AND(...this.searchOptionType.filter)
+            :
+            OR(...this.searchOptionType.filter);
+    }
+
+    /**
+     * @description to compose flatten-order string for @azure/search-documents
+     * @returns {Array<string>} flatten-order string
+     */
+    private composeOrder(): string[] {
+        return this.searchOptionType.orderBy.map(
+            (s: SearchOrder) => `${s.attr} ${s.orderBy}`
+        );
+    }
+
+    /**
+     * @description to compose flatten-facets string for @azure/search-documents
+     * @returns {Array<string>} flatten-facets string
+     */
+    private composeFacets(): string[] {
+        return this.searchOptionType.facets.map((s: SearchFacets) => {
+            let res = `${s.attr}`;
+            if (s.count !== null && s.count !== undefined) { res+= `,count:${s.count}`; }
+            if (!!s.sort) { res += `,sort:${s.sort}`; }
+            if (s.interval !== null && s.interval !== undefined) { res += `,interval:${s.interval}`; }
+            if (!!s.timeoffset) { res += `,timeoffset:${s.timeoffset}`; }
+            return res;
+        });
+    }
+
+    /**
+     * @description as an adaptor to transform the type for @azure/search-documents
+     * @returns {Object} object which can be accepted by @azure/search-documents
+     */
+    value = () => {
+        let value: {
+            select?: string[],
+            filter?: string;
+            orderBy?: string[],
+            includeTotalCount?: boolean,
+            top?: number,
+            skip?: number,
+            facets?: string[],
+            searchMode?: string,
+            searchFields?: string[],
+            scoringProfile?: string,
+            highlightFields?: string,
+            highlightPreTag?: string,
+            highlightPostTag?: string,
+            queryType?:string
+        } = {};
+
+        value.includeTotalCount = this.searchOptionType.count;
+        value.select = this.searchOptionType.select;
+        value.skip = this.searchOptionType.skip;
+        value.top = this.searchOptionType.top;
+        value.searchMode = this.searchOptionType.searchMode;
+        value.searchFields = this.searchOptionType.searchFields;
+        value.scoringProfile = this.searchOptionType.scoringProfile;
+        value.highlightFields = this.searchOptionType.highlightFields;
+        value.highlightPreTag = this.searchOptionType.highlightPreTag;
+        value.highlightPostTag = this.searchOptionType.highlightPostTag;
+        value.queryType = this.searchOptionType.queryType;
+        
+        if (!!this.searchOptionType.filter) {
+            value.filter = this.composeFilter();
+        }
+
+        if (!!this.searchOptionType.select && this.searchOptionType.select.length) {
+            value.select = this.searchOptionType.select;
+        }
+
+        if (!!this.searchOptionType.orderBy && this.searchOptionType.orderBy.length) {
+            value.orderBy = this.composeOrder();
+        }
+    
+        if (!!this.searchOptionType.facets && this.searchOptionType.facets.length) {
+            value.facets = this.composeFacets();
+        }
+
+        return value;
+    }
+}

package/src/lib/azure/cognitiveSearch/SearchOrder.ts

@@ -0,0 +1,9 @@
+/**
+ * @description SearchOrder as a type to depict the orderBy props
+ * @property {string} attr - the search field which is used to be sorted
+ * @property {'desc' | 'asc'} orderBy - descent or ascent
+ */
+ export type SearchOrder = {
+    attr: string;
+    orderBy: 'desc' | 'asc';
+}