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

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';
+}

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

@@ -0,0 +1,7 @@
+export * from './QueryType';
+export * from './SearchClient';
+export * from './SearchFacets';
+export * from './SearchFilter';
+export * from './SearchMode';
+export * from './SearchOption';
+export * from './SearchOrder';

package/src/lib/azure/index.ts

@@ -0,0 +1,7 @@
+export * from './cognitiveSearch';
+export * from './azureBlobStorage';
+export * from './azureKeyVault';
+export * from './azureServiceBusClient';
+export * from './azureServiceBusQueue';
+export * from './azureStorageQueue';
+export * from './azureTableStorage';

package/src/lib/fetch/index.ts

@@ -0,0 +1,2 @@
+export * from './sendRequest';
+export * from './sendRequestWithTimeout';

package/src/lib/fetch/sendRequest.ts

@@ -0,0 +1,10 @@
+import fetch from 'node-fetch';
+
+
+/**
+ * @description wrapper of node-fetch
+ * @param {string} url - request endpoint
+ * @param {any} options - fetch options
+ * @returns {any} response
+ */
+export const sendRequest = async (url: string, options: any) => await fetch(url, options);

package/src/lib/fetch/sendRequestWithTimeout.ts

@@ -0,0 +1,38 @@
+import fetch from 'node-fetch';
+import { AbortController } from '@azure/abort-controller';
+import { thirdPartyRegulation } from '../../utils/appConst';
+
+
+/**
+ * @description to store the current processing request, it should only be called 
+ * by function sendRequestWithTimeout
+ */
+const abortedSet: Set<string> = new Set<string>();
+
+/**
+ * @description send a request which will automatically abort within a given time 
+ * if the request is not response yet
+ * @param {string} url - url of request endpoint
+ * @param {any} options - fetch option
+ * @param {number} abortWithinMs - automatically abort after given millisecond
+ * @returns {any} response
+ */
+export async function sendRequestWithTimeout(
+    url: string,
+    options: any,
+    abortWithinMs: number = thirdPartyRegulation.requestLimitationMsec
+): Promise<any> {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => {
+        abortedSet.add(url);
+        controller.abort();
+    }, abortWithinMs);
+    try {
+        const response = await fetch(url, { signal: controller.signal, ...options});
+        clearTimeout(timeout);
+        return response;
+    } catch (err) {
+        if (abortedSet.has(url) && (err as Error).name === 'AbortError') { abortedSet.delete(url); }
+        throw err;
+    }
+}

package/src/lib/httpClient.ts

@@ -1,36 +1,37 @@
+import fetch, { Response, RequestInit } from 'node-fetch';
 import { UserInfo } from '../interfaces';
 import { getInternalClient, userInfoSimplifier } from '../utils/commonUtils';
 import { generateJWT } from '../utils/commonUtils';
 import {commonAppConst, jsonContentTypeHeaders } from '../utils/appConst';
-const fetch = require('node-fetch');
+import { logger } from '../utils/logger/logger';
 
 export async function httpRequest(method: string, url : string,  data: any = null, headers : any = jsonContentTypeHeaders()): Promise<Response> {
-  let init = {};
-  init = data === null ?  {
-      method: method,
-      cache: "no-cache",
-      headers: headers
-  } : {
-    method: method,
-    cache: "no-cache",
-    headers: headers,
-    body: JSON.stringify(data)
-  };
-
-  return fetch(url, init);
+    const init: RequestInit = {
+        method,
+        headers,
+        body: data === null ? undefined : JSON.stringify(data)
+    }
+    return fetch(url, init);
 }
 
 export async function sendInternalHttpRequest(userInfo:UserInfo, client: string, endpoint: string, data: any = null, method?: string, select?:string[]) {
-  method = method ?? commonAppConst.httpMethod.POST;
-  const internalClient = await getInternalClient(client)
-  const url = internalClient + endpoint;
-  let headers:any = jsonContentTypeHeaders();
-  if(userInfo){
-    userInfo = await userInfoSimplifier(userInfo, select)
-    let token: string = `${commonAppConst.httpHeader.BEARER} ${await generateJWT(userInfo)}`;
-    headers[commonAppConst.httpHeader.AUTHORIZATION] = token;
-  }
-  return httpRequest(method, url, data, headers).then(response => {
-    return response.json()
-  })
+    method = method ?? commonAppConst.httpMethod.POST;
+    const internalClient = await getInternalClient(client)
+    const url = internalClient + endpoint;
+    let headers:any = jsonContentTypeHeaders();
+    if(userInfo){
+        userInfo = await userInfoSimplifier(userInfo, select)
+        let token: string = `${commonAppConst.httpHeader.BEARER} ${await generateJWT(userInfo)}`;
+        headers[commonAppConst.httpHeader.AUTHORIZATION] = token;
+    }
+
+    let response: Response;
+    try {
+        response = await httpRequest(method, url, data, headers);
+        return response.json();
+    }
+    catch (err) {
+        logger.error(`Error while sending internal http request, receiving response: ${response}`);
+        throw new Error(`${err}`);
+    }
 }

package/src/lib/index.ts

@@ -0,0 +1,3 @@
+export * from './azure';
+export * from './fetch';
+export * from './teams';

package/src/lib/teams/broadcastLogMessage.ts

@@ -0,0 +1,70 @@
+import { LogLevel, LogMessage } from './logMessage';
+import { appConfig, loadConfig } from '../../utils/middleware/loadConfig';
+import { sendRequestWithTimeout } from '../fetch';
+
+
+/**
+ * @description broadcast log message to specific Microsoft Teams channels
+ * @param {LogLevel} level - level of the log
+ * @param {string} message - log message
+ * @returns {void} the function is deposable, thus it won't return any of information
+ */
+export async function broadcastLogMessage(level: LogLevel, message: string) {
+    // we only broadcast two levels of log.
+    if (level !== 'error' && level !== 'warn') { return; }
+
+    /**
+     * 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();
+        } catch (err) {
+            throw err;
+        }
+    }
+
+    const time = new Date().toISOString();
+    const logMessage: LogMessage = {
+        level,
+        message,
+        time,
+        environment: appConfig.environment,
+        appName: appConfig.appName,
+        version: appConfig.version
+    };
+
+    const messageCard: Object = ((): Object => {
+        return {
+            '@type': 'MessageCard',
+            '@context': 'http://schema.org/extensions',
+            'summary': 'Teams broadcasting of Logs',
+            'sections': [{
+                'activityTitle': `# ***Service Error Log - ${logMessage.level}***`,
+                'facts': [
+                    { 'name': 'Time', 'value': logMessage.time },
+                    { 'name': 'Environment', 'value': logMessage.environment },
+                    { 'name': 'Service', 'value': logMessage.appName },
+                    { 'name': 'Version', 'value': logMessage.version }, 
+                    { 'name': 'Message', 'value': logMessage.message }
+                ],
+                'markdown': true
+            }],
+            'potentialAction': [
+                {
+                    '@type': 'OpenUri',
+                    'name': 'View Documentation',
+                    'targets': [ { 'os': 'default', 'uri': '' } ]
+                }
+            ]
+        }
+    })();
+
+    const url = level === 'error' ? 
+        appConfig.telemetry.teamsChannelWebHook.errorChannel
+        :
+        appConfig.telemetry.teamsChannelWebHook.warnChannel;
+
+    await sendRequestWithTimeout(url, { method: 'POST', body: JSON.stringify(messageCard) });
+}

package/src/lib/teams/index.ts

@@ -0,0 +1,2 @@
+export * from './broadcastLogMessage';
+export * from './logMessage';

package/src/lib/teams/logMessage.ts

@@ -0,0 +1,55 @@
+import { Environment } from '../../utils';
+import { z } from 'zod';
+
+
+/**
+ * @description we classified the logs into 4 levels and one supporting level:
+ *  - `verbose`: The most fine-grained information only used in rare cases where 
+ *  you need the full visibility of what is happening in your application 
+ *  and inside the third-party libraries that you use
+ *  - `info`: The standard log level indicating that something happened; 
+ *  the application entered a certain state. It should be purely informative and
+ *  not looking into them on a regular basis
+ *  - `warn`: the log level that indicates that something unexpected happened in
+ *  the application, a problem, or a situation that might disturb one of the
+ *  processes. But that doesn’t mean that the application failed
+ *  - `error`: error, states as `FATAL` in the modern log leveling to alleviate DRY.
+ *  It tells that the application encountered an event or entered a state in which 
+ * one of the crucial business functionality is no longer working
+ *  - `disabled`: supporting enum for disabling the functionality of logger
+ * 
+ * @example
+ * ```markdown
+ *  - verbose: annotate each step in the algorithm or each individual query 
+ *  with parameters in your code
+ *  - info: request of authorization API which states whether a user sign-on success or not
+ *  - warn`: a parsing error occurred that resulted in a certain document not being processed
+ *  - error: when the application is not able to connect to a crucial data store like a database
+ *  or one of the sub-service is unavailable
+ * ```
+ * @see https://sematext.com/blog/logging-levels/
+ */
+export const zLogLevel = z.enum(['verbose', 'info', 'warn', 'error', 'disabled']);
+
+/**
+ * @description typedef of `zLogLevel`
+ */
+export type LogLevel = z.infer<typeof zLogLevel>;
+ 
+/**
+ * @description definition of the context that a log should contains
+ * @property {LogLevel} level - log level
+ * @property {string} time - when does the log be generated
+ * @property {string} appName - the service which generates the logs
+ * @property {Environment} environment - log happened in which environment
+ * @property {string} message - log message
+ * @property {string} version - current app version
+ */
+export type LogMessage = {
+    level: LogLevel;
+    time: string;
+    appName: string;
+    environment: Environment;
+    message: string;
+    version: string;
+}

package/src/utils/appConfig.ts

@@ -1,5 +1,5 @@
 import dotenv from 'dotenv';
-import { commonAppConst } from './appConst';
+
 if (process.env.NODE_ENV !== undefined) {
     dotenv.config({ path: `${process.env.NODE_ENV}.env` });
 }
@@ -49,4 +49,4 @@ export const commonAppConfig = {
     DailyDigest: process.env.DAILYDIGEST_CLIENT,
     Announcement: process.env.ANNOUNCEMENT_CLIENT,
     APIM: process.env.APIM_CLIENT,
-}
+}

package/src/utils/appConst.ts

@@ -1,3 +1,5 @@
+import { z } from 'zod';
+
 export const commonAppConst = {
 	emptyGuid: '00000000-0000-0000-0000-000000000000',
 	sampleStatus: {
@@ -155,3 +157,65 @@ export const exitErrorMessage:Record<string, string> = {
 	SQLQueryRunner: `Requests can only be made in the LoggedIn state, not the SentClientRequest state`,
 	UnknownTimeout: `operation timed out for an unknown reason`
 }
+
+/**
+ * @description environment cuts some of the functionalities, including log levels
+ * and local-env file location, to optimize our services.
+ * @enum {string}
+ */
+export const zEnvironment = z.enum(['test', 'dev', 'development', 'preview', 'staging', 'beta', 'production']);
+
+/**
+ * @description typedef of `zEnvironment`
+ */
+export type Environment = z.infer<typeof zEnvironment>;
+
+/**
+ * @description const to regulate, control the third parties' usage
+ * @property {number} requestLimitationMsec - default request abort time
+ * @property {number} requestDefaultRetry - default retry times if the request is failed
+ */
+export const thirdPartyRegulation = {
+    requestLimitationMsec: 5000,
+    requestDefaultRetry: 2
+};
+
+/**
+ * @description settings for logger
+ * @property {string} path - local storage path of log files
+ * @property {boolean} teamsChannelDisabled - when the log level is `warn`/`error`, 
+ * the messages will be delivered to the Teams channel
+ */
+export const loggerSettings = {
+    path: './log/',
+    teamsChannelDisabled: true
+};
+
+/**
+ * @description Index of Azure Cognitive Search
+ * @enum {string}
+ */
+export enum AzureSearchIndex {
+    news = 'news',
+    company = 'company',
+    market = 'market',
+    financial = 'financial',
+    ott = 'ott',
+    nerl = 'nerl',
+    people = 'people',
+    relationship = 'relationship'
+};
+
+/**
+ * @description configuration of Azure Cognitive Search
+ * @property {number} queryRetryDefault - default retry times for query
+ * @property {number} retryIntervalSecond - retry after waiting given second
+ * @property {string} credentialSecretName - credential secret name saved in Azure Key Vault
+ * @property {string} indexSecretName - index secret name saved in Azure Key Vault
+ */
+export const AzureSearchConfig = {
+    queryRetryDefault: 3,
+    retryIntervalSecond: 1,
+    credentialSecretName: 'SkyEye-SVC-Search-Credential',
+    indexSecretName: 'SkyEye-SVC-Search-Index'
+};