@huaweicloud/huaweicloud-sdk-core 3.1.26 → 3.1.28

package/CHANGELOG.md

@@ -1,3 +1,62 @@
+# 3.1.28 2023-03-09
+
+### HuaweiCloud SDK AOS
+
+- _Features_
+  - Support the following interfaces：
+    - `ListTemplates`
+    - `DeleteTemplate`
+    - `ShowTemplateMetadata`
+    - `UpdateTemplateMetadata`
+    - `ShowTemplateVersionContent`
+    - `DeleteTemplateVersion`
+    - `ShowTemplateVersionMetadata`
+- _Bug Fix_
+  - None
+- _Change_
+  - Changes of the interface `ListExecutionPlans`:
+    - Add the enum values `APPLY_IN_PROGRESS` to the response parameter `status`
+    - The response parameter `stack_name`, `execution_plan_name` changed to required
+  - Remove the enum values `IN_PLACE_UPDATE` from the response parameter `action` from the interface `GetExecutionPlan`
+  - The response parameter `stack_name`, `execution_plan_name` changed to required of the interface `GetExecutionPlanMetadata`
+  - Add the response parameter `resource_attributes` to the interface `ListStackResources`
+  - Changes of the interface `EstimateExecutionPlanPrice`:
+    - Add the response parameter `unsupported_message`
+    - Modify the type `object` -> `double` of the response parameter `sale_price`
+    - Modify the type `object` -> `double` of the response parameter `discount`
+    - Modify the type `object` -> `double` of the response parameter `original_price`
+    - Remove the enum values `WEEK` from the response parameter `period_type`
+
+### HuaweiCloud SDK IoTDA
+
+- _Features_
+  - None
+- _Bug Fix_
+  - None
+- _Change_
+  - Add the response parameters `connection_status_update_time`, `active_time` to the interface `UpdateDevice`
+  - Add the response parameters `connection_status_update_time`, `active_time` to the interface `ShowDevice`
+
+### HuaweiCloud SDK OCR
+
+- _Features_
+  - None
+- _Bug Fix_
+  - None
+- _Change_
+  - Add the request parameter `extended_parameters` to the interface `RecognizeAutoClassification`
+
+# 3.1.27 2023-03-07
+
+### HuaweiCloud SDK VOD
+
+- _Features_
+  - Support the interface `ModifySubtitle`
+- _Bug Fix_
+  - None
+- _Change_
+  - None
+
 # 3.1.26 2023-03-02
 
 ### HuaweiCloud SDK CDN

package/CHANGELOG_CN.md

@@ -1,3 +1,62 @@
+# 3.1.28 2023-03-09
+
+### HuaweiCloud SDK AOS
+
+- _新增特性_
+  - 支持以下接口：
+    - `ListTemplates`
+    - `DeleteTemplate`
+    - `ShowTemplateMetadata`
+    - `UpdateTemplateMetadata`
+    - `ShowTemplateVersionContent`
+    - `DeleteTemplateVersion`
+    - `ShowTemplateVersionMetadata`
+- _解决问题_
+  - 无
+- _特性变更_
+  - 接口`ListExecutionPlans`:
+    - 响应参数`status`新增枚举值`APPLY_IN_PROGRESS`
+    - 响应参数`stack_name`、`execution_plan_name`改为必填
+  - 接口`GetExecutionPlan`响应参数`action`移除枚举值`IN_PLACE_UPDATE`
+  - 接口`GetExecutionPlanMetadata`响应参数`stack_name`、`execution_plan_name`改为必填
+  - 接口`ListStackResources`新增响应参数 `resource_attributes`
+  - 接口`EstimateExecutionPlanPrice`:
+    - 新增响应参数 `unsupported_message`
+    - 响应参数`sale_price`类型调整 `object` -> `double`
+    - 响应参数`discount`类型调整 `object` -> `double`
+    - 响应参数`original_price`类型调整 `object` -> `double`
+    - 响应参数`period_type`移除枚举值`WEEK`
+
+### HuaweiCloud SDK IoTDA
+
+- _新增特性_
+  - 无
+- _解决问题_
+  - 无
+- _特性变更_
+  - 接口`UpdateDevice`新增响应参数 `connection_status_update_time`、`active_time`
+  - 接口`ShowDevice`新增响应参数 `connection_status_update_time`、`active_time`
+
+### HuaweiCloud SDK OCR
+
+- _新增特性_
+  - 无
+- _解决问题_
+  - 无
+- _特性变更_
+  - 接口`RecognizeAutoClassification`新增请求参数 `extended_parameters`
+
+# 3.1.27 2023-03-07
+
+### HuaweiCloud SDK VOD
+
+- _新增特性_
+  - 支持接口`ModifySubtitle`
+- _解决问题_
+  - 无
+- _特性变更_
+  - 无
+
 # 3.1.26 2023-03-02
 
 ### HuaweiCloud SDK CDN

package/ClientBuilder.d.ts

@@ -2,37 +2,32 @@ import { HcClient } from "./HcClient";
 import { ICredential } from "./auth/ICredential";
 import { Region } from "./region/region";
 import { UserOptions } from "./UserOptions";
-interface CredParams {
-    ak?: string;
-    sk?: string;
-    project_id?: string;
-    domain_id?: string;
-}
 export declare class ClientBuilder<T> {
     private init;
-    private endpoint?;
+    private endpoints?;
     private credential?;
     private proxyAgent?;
     private credentialType;
     private envParams;
     private region?;
     private userOptions?;
+    private credentials;
     constructor(init: (hcClient: HcClient) => T, credentialType?: string);
-    withEndpoint(endpoint: string): ClientBuilder<T>;
+    withEndpoint(endpoint: string | string[]): ClientBuilder<T>;
     withCredential(credential?: ICredential): ClientBuilder<T>;
     withProxyAgent(proxyAgent: string): ClientBuilder<T>;
     withRegion(region: Region): ClientBuilder<T>;
     withOptions(options: UserOptions): ClientBuilder<T>;
     build(): T;
     /**
-     * 从环境变量获取 HUAWEICLOUD_SDK_TYPE
-     * 环境变量里没有则使用 credentialType[0]
-     * 生成credential实体
-     * 从环境变量获取 AK SK projectId/domainId 进行赋值， 如果环境变量是GlobalCredentials，则赋值domainId
-     * @returns Credentials
+     * Get 'HUAWEICLOUD_SDK_TYPE' from environment variables
+     * If the variable does not exist, use the first credential type
+     * Generate credential entity
+     * Assign AK, SK, projectId/domainId from the environment variables
+     * If the environment variable is 'GlobalCredentials', assign the domainId
+     * @returns ICredential
      */
-    getCredentialFromEnvironment(): ICredential;
-    whichCredential(sdkType: string): any;
-    getInputParamCredential(CredentialsType: any, credential: CredParams): any;
+    private getCredentialFromEnvironment;
+    private whichCredential;
+    private getInputParamCredential;
 }
-export {};

package/ClientBuilder.js

@@ -1,6 +1,6 @@
 "use strict";
 /*
- * Copyright 2020 Huawei Technologies Co.,Ltd.
+ * Copyright 2023 Huawei Technologies Co.,Ltd.
  *
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
@@ -54,13 +54,21 @@ var ClientBuilder = /** @class */ (function () {
     function ClientBuilder(init, credentialType) {
         this.credentialType = ["BasicCredentials", "GlobalCredentials"];
         this.envParams = process.env;
+        this.credentials = {};
         this.init = init;
         if (credentialType) {
             this.credentialType = credentialType.split(",");
         }
     }
     ClientBuilder.prototype.withEndpoint = function (endpoint) {
-        this.endpoint = endpoint;
+        var _a;
+        this.endpoints = [];
+        if (typeof endpoint === 'string') {
+            this.endpoints.push(endpoint);
+        }
+        else if (Array.isArray(endpoint)) {
+            (_a = this.endpoints).push.apply(_a, endpoint);
+        }
         return this;
     };
     ClientBuilder.prototype.withCredential = function (credential) {
@@ -100,20 +108,22 @@ var ClientBuilder = /** @class */ (function () {
         if (!this.credential) {
             throw new SdkException_1.SdkException("credential can not be null, ".concat(this.credentialType, "Credential objects are required"));
         }
-        var client = new DefaultHttpClient_1.DefaultHttpClient(axiosOptions);
-        var hcClient = new HcClient_1.HcClient(client);
-        hcClient.withEndpoint(this.endpoint).withCredential(this.credential);
         if (this.region) {
-            hcClient.withRegion(this.region);
+            this.endpoints = this.region.endpoints;
         }
+        var client = new DefaultHttpClient_1.DefaultHttpClient(axiosOptions, this.endpoints);
+        var hcClient = new HcClient_1.HcClient(client);
+        this.region && hcClient.withRegion(this.region);
+        hcClient.withCredential(this.credential).withEndpoints(this.endpoints);
         return this.init(hcClient);
     };
     /**
-     * 从环境变量获取 HUAWEICLOUD_SDK_TYPE
-     * 环境变量里没有则使用 credentialType[0]
-     * 生成credential实体
-     * 从环境变量获取 AK SK projectId/domainId 进行赋值， 如果环境变量是GlobalCredentials，则赋值domainId
-     * @returns Credentials
+     * Get 'HUAWEICLOUD_SDK_TYPE' from environment variables
+     * If the variable does not exist, use the first credential type
+     * Generate credential entity
+     * Assign AK, SK, projectId/domainId from the environment variables
+     * If the environment variable is 'GlobalCredentials', assign the domainId
+     * @returns ICredential
      */
     ClientBuilder.prototype.getCredentialFromEnvironment = function () {
         var sdkType = process.env.HUAWEICLOUD_SDK_TYPE;
@@ -121,62 +131,44 @@ var ClientBuilder = /** @class */ (function () {
         return this.getInputParamCredential(credentialTYPE, this.envParams);
     };
     ClientBuilder.prototype.whichCredential = function (sdkType) {
-        var credentialTYPE;
-        if (sdkType) {
-            switch (sdkType) {
-                case 'BasicCredentials':
-                    credentialTYPE = new BasicCredentials_1.BasicCredentials();
-                    break;
-                case 'GlobalCredentials':
-                    credentialTYPE = new GlobalCredentials_1.GlobalCredentials();
-                    break;
-                default:
-                    var obj = {};
-                    var definedCredPath = path.join(this.init().getPath(), "".concat(sdkType));
-                    if (!obj[sdkType]) {
-                        credentialTYPE = require(definedCredPath);
-                        // 多加一层
-                        obj[sdkType] = credentialTYPE[sdkType];
-                    }
-                    credentialTYPE = new obj[sdkType]();
-                    break;
-            }
+        if (!sdkType) {
+            return new BasicCredentials_1.BasicCredentials();
         }
-        else {
-            // 默认是basic
-            credentialTYPE = new BasicCredentials_1.BasicCredentials();
+        switch (sdkType) {
+            case 'BasicCredentials':
+                return new BasicCredentials_1.BasicCredentials();
+            case 'GlobalCredentials':
+                return new GlobalCredentials_1.GlobalCredentials();
+            default:
+                if (this.credentials[sdkType]) {
+                    return this.credentials[sdkType];
+                }
+                var definedCredPath = path.join(this.init().getPath(), "".concat(sdkType));
+                var credentialTYPE = require(definedCredPath);
+                this.credentials[sdkType] = new credentialTYPE();
+                return this.credentials[sdkType];
         }
-        return credentialTYPE;
     };
     ClientBuilder.prototype.getInputParamCredential = function (CredentialsType, credential) {
-        // 判断是否有_
-        var hash = {};
-        for (var key in credential) {
-            if (key.indexOf("HUAWEICLOUD_SDK_") == 0) {
-                var value = credential[key];
-                key = key.substring(16);
-                if (key.indexOf('_') == -1) {
-                    key = key.toLowerCase();
-                    key = 'with' + key.charAt(0).toUpperCase() + key.slice(1);
-                }
-                else {
-                    var arr = key.split('_').map(function (item) {
-                        item = item.toLowerCase();
-                        return item.charAt(0).toUpperCase() + item.slice(1);
-                    });
-                    if (Array.isArray(arr)) {
-                        key = 'with' + arr.join("");
-                    }
-                }
-                hash[key] = value;
+        var hash = Object.keys(credential)
+            .filter(function (key) { return key.indexOf("HUAWEICLOUD_SDK_") === 0; })
+            .reduce(function (acc, key) {
+            var newKey = key.substring(16);
+            if (newKey.indexOf('_') === -1) {
+                newKey = "with".concat(newKey.toLowerCase().replace(/^\w/, function (c) { return c.toUpperCase(); }));
             }
-        }
-        credential = hash;
-        for (var key in credential) {
+            else {
+                newKey = newKey.split('_').map(function (word) { return "".concat(word.toLowerCase().replace(/^\w/, function (c) { return c.toUpperCase(); })); }).join('');
+                newKey = "with".concat(newKey);
+            }
+            acc[newKey] = credential[key];
+            return acc;
+        }, {});
+        Object.keys(hash).forEach(function (key) {
             if (CredentialsType[key]) {
-                CredentialsType[key](credential[key]);
+                CredentialsType[key](hash[key]);
             }
-        }
+        });
         return CredentialsType;
     };
     return ClientBuilder;

package/HcClient.d.ts

@@ -2,20 +2,32 @@ import { HttpClient } from "./http/HttpClient";
 import { ICredential } from "./auth/ICredential";
 import { SdkResponse } from "./SdkResponse";
 import { Region } from "./region/region";
+import { ClientOptions } from "./http/DefaultHttpClient";
+export interface HttpRequestOptions {
+    method: string;
+    url: string;
+    contentType: string;
+    queryParams: Record<string, any>;
+    pathParams: Record<string, any>;
+    headers: Record<string, string>;
+    data: Record<string, any>;
+}
 export declare class HcClient {
     private httpClient;
-    private endpoint;
-    private credential;
+    private credential?;
     private proxyAgent;
     private static loggerName;
     private logger;
-    region?: Region;
-    constructor(client: HttpClient);
-    withEndpoint(endpoint?: string): HcClient;
+    private region?;
+    private clientOptions?;
+    private endpoints?;
+    constructor(client: HttpClient, clientOptions?: ClientOptions);
+    withEndpoints(endpoints?: string[]): this;
     withCredential(credential?: ICredential): HcClient;
-    withRegion(region?: Region): this;
-    withHttpsAgent(proxyAgent: string): this;
-    sendRequest<T extends SdkResponse>(options: any): Promise<any>;
+    withRegion(region?: Region): HcClient;
+    withHttpsAgent(proxyAgent: string): HcClient;
+    overrideEndpoints(endpoint?: string[]): HcClient;
+    sendRequest<T extends SdkResponse>(options: HttpRequestOptions): Promise<T>;
     private buildRequest;
     private extractResponse;
 }

package/HcClient.js

@@ -1,6 +1,6 @@
 "use strict";
 /*
- * Copyright 2020 Huawei Technologies Co.,Ltd.
+ * Copyright 2023 Huawei Technologies Co.,Ltd.
  *
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
@@ -61,16 +61,18 @@ var IHttpRequestBuilder_1 = require("./http/IHttpRequestBuilder");
 var ExceptionUtil_1 = require("./exception/ExceptionUtil");
 var logger_1 = require("./logger");
 var SdkStreamResponse_1 = require("./SdkStreamResponse");
+var DefaultHttpClient_1 = require("./http/DefaultHttpClient");
 var HcClient = /** @class */ (function () {
-    function HcClient(client) {
+    function HcClient(client, clientOptions) {
         this.proxyAgent = '';
         this.httpClient = client;
         // Logging
         this.logger = (0, logger_1.getLogger)(HcClient.loggerName, logger_1.LogLevel.INFO);
         this.logger.debug('initialized');
+        this.clientOptions = clientOptions;
     }
-    HcClient.prototype.withEndpoint = function (endpoint) {
-        this.endpoint = endpoint;
+    HcClient.prototype.withEndpoints = function (endpoints) {
+        this.endpoints = endpoints;
         return this;
     };
     HcClient.prototype.withCredential = function (credential) {
@@ -85,75 +87,81 @@ var HcClient = /** @class */ (function () {
         this.proxyAgent = proxyAgent;
         return this;
     };
+    HcClient.prototype.overrideEndpoints = function (endpoint) {
+        var client = new DefaultHttpClient_1.DefaultHttpClient(this.clientOptions, endpoint);
+        return new HcClient(client, this.clientOptions).withCredential(this.credential).withEndpoints(endpoint);
+    };
     HcClient.prototype.sendRequest = function (options) {
         return __awaiter(this, void 0, void 0, function () {
-            var request;
-            var _this = this;
+            var request, response, error_1;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
                         this.logger.debug('send request');
+                        this.httpClient.credentials = this.credential;
                         return [4 /*yield*/, this.buildRequest(options)];
                     case 1:
                         request = _a.sent();
-                        // @ts-ignore
-                        return [2 /*return*/, this.httpClient.sendRequest(request).then(function (res) {
-                                return _this.extractResponse(res);
-                            }, function (err) {
-                                return ExceptionUtil_1.ExceptionUtil.generalException(err);
-                            })];
+                        this.httpClient.httpRequest = request;
+                        _a.label = 2;
+                    case 2:
+                        _a.trys.push([2, 4, , 5]);
+                        return [4 /*yield*/, this.httpClient.sendRequest(request)];
+                    case 3:
+                        response = _a.sent();
+                        return [2 /*return*/, this.extractResponse(response)];
+                    case 4:
+                        error_1 = _a.sent();
+                        throw ExceptionUtil_1.ExceptionUtil.generalException(error_1);
+                    case 5: return [2 /*return*/];
                 }
             });
         });
     };
     HcClient.prototype.buildRequest = function (options) {
+        var _a;
         return __awaiter(this, void 0, void 0, function () {
-            var _a, url, pathParams, builder, httpRequest;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
+            var _b, url, builder, httpRequest;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
                     case 0:
                         if (!this.region) return [3 /*break*/, 2];
-                        this.endpoint = this.region.endpoint;
-                        _a = this;
+                        _b = this;
                         return [4 /*yield*/, this.credential.processAuthParams(this, this.region.id)];
                     case 1:
-                        _a.credential = _b.sent();
-                        _b.label = 2;
+                        _b.credential = _c.sent();
+                        _c.label = 2;
                     case 2:
-                        url = this.endpoint + options.url;
-                        pathParams = options.pathParams;
-                        Object.keys(pathParams).forEach(function (x) {
-                            url = url.replace("{" + x + "}", pathParams[x]);
+                        url = "".concat(options.url);
+                        Object.entries(options.pathParams).forEach(function (_a) {
+                            var key = _a[0], value = _a[1];
+                            url = url.replace("{".concat(key, "}"), value + '');
                         });
                         if (options.method === 'DELETE'
                             && (options.data && (Object.keys(options.data).length <= 0 || options.data.length <= 0))) {
                             delete options.data;
                         }
-                        if (options.headers && Object.prototype.hasOwnProperty.call(options.headers, "Content-Type")) {
+                        if ((_a = options.headers) === null || _a === void 0 ? void 0 : _a['Content-Type']) {
                             delete options.headers['Content-Type'];
                         }
                         if (options.contentType) {
                             if (!options.headers) {
                                 options.headers = {};
                             }
-                            if (options.contentType.toLowerCase().startsWith("application/json")) {
-                                // remove charset
-                                options.headers['content-type'] = "application/json";
-                            }
-                            else {
-                                options.headers['content-type'] = options.contentType;
-                            }
+                            options.headers['content-type'] = options.contentType.toLowerCase().includes('application/json')
+                                ? 'application/json'
+                                : options.contentType;
                         }
                         builder = new IHttpRequestBuilder_1.HttpRequestBuilder();
                         httpRequest = builder
-                            .withEndpoint(url)
+                            .withEndpoint(this.endpoints[0])
+                            .withUrl(url)
                             .withHeaders(options.headers)
                             .withMethod(options.method)
                             .withPathParams(options.pathParams)
                             .withData(options.data)
                             .withQueryParams(options.queryParams)
                             .build();
-                        // @ts-ignore
                         httpRequest = this.credential.processAuthRequest(httpRequest);
                         if (options['responseHeaders']) {
                             httpRequest['responseHeaders'] = options['responseHeaders'];
@@ -168,24 +176,18 @@ var HcClient = /** @class */ (function () {
         });
     };
     HcClient.prototype.extractResponse = function (result) {
+        var _a;
         var headers = result.headers;
-        var contentType = headers['content-type'];
-        contentType = contentType === null || contentType === void 0 ? void 0 : contentType.toLowerCase();
-        if (contentType
-            && (contentType.startsWith('application/octet-stream')
-                || contentType.startsWith("image")
-                || contentType.startsWith("application/zip"))) {
+        var contentType = (_a = headers['content-type']) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+        if (/(application\/octet-stream|image|application\/zip)/.test(contentType)) {
             var streamRes = new SdkStreamResponse_1.SdkStreamResponse();
             streamRes.body = result.data;
             streamRes.httpStatusCode = result.statusCode;
             return streamRes;
         }
-        else {
-            var response = result.data instanceof Object ? result.data : {};
-            var sdkRespone = response;
-            sdkRespone.httpStatusCode = result.statusCode;
-            return sdkRespone;
-        }
+        var response = typeof result.data === 'object' ? result.data : {};
+        response.httpStatusCode = result.statusCode;
+        return response;
     };
     HcClient.loggerName = 'HcClient';
     return HcClient;