@wildix/wim-cache-client 1.0.0 → 1.0.2

package/dist-es/WimCacheClient.js

@@ -1,15 +1,22 @@
 import { getRuntimeConfig as __getRuntimeConfig } from "./runtimeConfig";
 import { resolveRuntimeExtensions, } from "./runtimeExtensions";
+import { getUserAgentPlugin, resolveUserAgentConfig, } from "@aws-sdk/middleware-user-agent";
+import { getContentLengthPlugin } from "@smithy/middleware-content-length";
+import { getRetryPlugin, resolveRetryConfig, } from "@smithy/middleware-retry";
 import { Client as __Client, } from "@smithy/smithy-client";
-import { authorizationMiddleware } from "@wildix/smithy-utils";
+import { authorizationMiddleware } from '@wildix/smithy-utils';
 export { __Client };
 export class WimCacheClient extends __Client {
+    config;
     constructor(...[configuration]) {
         let _config_0 = __getRuntimeConfig(configuration || {});
-        let _config_1 = resolveRuntimeExtensions(_config_0, configuration?.extensions || []);
+        super(_config_0);
+        this.initConfig = _config_0;
+        let _config_1 = resolveUserAgentConfig(_config_0);
+        let _config_2 = resolveRetryConfig(_config_1);
+        let _config_3 = resolveRuntimeExtensions(_config_2, configuration?.extensions || []);
+        const hostname = ['stable', 'stage'].includes(configuration.env || '') ? `wim-${configuration.env}.wildix.com` : 'wim.wildix.com';
         const endpoint = () => {
-            let env = configuration.env && configuration.env !== 'prod' ? '-' + configuration.env : '';
-            const hostname = `wim${env}.wildix.com`;
             return {
                 hostname,
                 protocol: "https",
@@ -17,13 +24,12 @@ export class WimCacheClient extends __Client {
                 path: ''
             };
         };
-        const config = {
-            ..._config_1,
-            endpoint,
-        };
-        super(config);
+        const config = { ..._config_3, endpoint };
         this.config = config;
         this.middlewareStack.add(authorizationMiddleware.bind(this, configuration.token), { step: "build" });
+        this.middlewareStack.use(getUserAgentPlugin(this.config));
+        this.middlewareStack.use(getRetryPlugin(this.config));
+        this.middlewareStack.use(getContentLengthPlugin(this.config));
     }
     destroy() {
         super.destroy();

package/dist-es/commands/DeleteEntitiesFromGeneralCacheCommand.js

@@ -1,37 +1,17 @@
 import { de_DeleteEntitiesFromGeneralCacheCommand, se_DeleteEntitiesFromGeneralCacheCommand, } from "../protocols/Aws_restJson1";
 import { getSerdePlugin } from "@smithy/middleware-serde";
 import { Command as $Command } from "@smithy/smithy-client";
-import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
 export { $Command };
-export class DeleteEntitiesFromGeneralCacheCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
-    }
-    resolveMiddleware(clientStack, configuration, options) {
-        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "WimCacheClient";
-        const commandName = "DeleteEntitiesFromGeneralCacheCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
-            inputFilterSensitiveLog: (_) => _,
-            outputFilterSensitiveLog: (_) => _,
-            [SMITHY_CONTEXT_KEY]: {
-                service: "WimCache",
-                operation: "DeleteEntitiesFromGeneralCache",
-            },
-        };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
-        return se_DeleteEntitiesFromGeneralCacheCommand(input, context);
-    }
-    deserialize(output, context) {
-        return de_DeleteEntitiesFromGeneralCacheCommand(output, context);
-    }
+export class DeleteEntitiesFromGeneralCacheCommand extends $Command.classBuilder()
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+    ];
+})
+    .s("WimCache", "DeleteEntitiesFromGeneralCache", {})
+    .n("WimCacheClient", "DeleteEntitiesFromGeneralCacheCommand")
+    .f(void 0, void 0)
+    .ser(se_DeleteEntitiesFromGeneralCacheCommand)
+    .de(de_DeleteEntitiesFromGeneralCacheCommand)
+    .build() {
 }

package/dist-es/commands/GetEntitiesByIdsCommand.js

@@ -1,37 +1,17 @@
 import { de_GetEntitiesByIdsCommand, se_GetEntitiesByIdsCommand, } from "../protocols/Aws_restJson1";
 import { getSerdePlugin } from "@smithy/middleware-serde";
 import { Command as $Command } from "@smithy/smithy-client";
-import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
 export { $Command };
-export class GetEntitiesByIdsCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
-    }
-    resolveMiddleware(clientStack, configuration, options) {
-        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "WimCacheClient";
-        const commandName = "GetEntitiesByIdsCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
-            inputFilterSensitiveLog: (_) => _,
-            outputFilterSensitiveLog: (_) => _,
-            [SMITHY_CONTEXT_KEY]: {
-                service: "WimCache",
-                operation: "GetEntitiesByIds",
-            },
-        };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
-        return se_GetEntitiesByIdsCommand(input, context);
-    }
-    deserialize(output, context) {
-        return de_GetEntitiesByIdsCommand(output, context);
-    }
+export class GetEntitiesByIdsCommand extends $Command.classBuilder()
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+    ];
+})
+    .s("WimCache", "GetEntitiesByIds", {})
+    .n("WimCacheClient", "GetEntitiesByIdsCommand")
+    .f(void 0, void 0)
+    .ser(se_GetEntitiesByIdsCommand)
+    .de(de_GetEntitiesByIdsCommand)
+    .build() {
 }

package/dist-es/commands/PutEntitiesToGeneralCacheCommand.js

@@ -1,37 +1,17 @@
 import { de_PutEntitiesToGeneralCacheCommand, se_PutEntitiesToGeneralCacheCommand, } from "../protocols/Aws_restJson1";
 import { getSerdePlugin } from "@smithy/middleware-serde";
 import { Command as $Command } from "@smithy/smithy-client";
-import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
 export { $Command };
-export class PutEntitiesToGeneralCacheCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
-    }
-    resolveMiddleware(clientStack, configuration, options) {
-        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "WimCacheClient";
-        const commandName = "PutEntitiesToGeneralCacheCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
-            inputFilterSensitiveLog: (_) => _,
-            outputFilterSensitiveLog: (_) => _,
-            [SMITHY_CONTEXT_KEY]: {
-                service: "WimCache",
-                operation: "PutEntitiesToGeneralCache",
-            },
-        };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
-        return se_PutEntitiesToGeneralCacheCommand(input, context);
-    }
-    deserialize(output, context) {
-        return de_PutEntitiesToGeneralCacheCommand(output, context);
-    }
+export class PutEntitiesToGeneralCacheCommand extends $Command.classBuilder()
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+    ];
+})
+    .s("WimCache", "PutEntitiesToGeneralCache", {})
+    .n("WimCacheClient", "PutEntitiesToGeneralCacheCommand")
+    .f(void 0, void 0)
+    .ser(se_PutEntitiesToGeneralCacheCommand)
+    .de(de_PutEntitiesToGeneralCacheCommand)
+    .build() {
 }

package/dist-es/commands/SearchEntitiesByListParamsCommand.js

@@ -1,37 +1,17 @@
 import { de_SearchEntitiesByListParamsCommand, se_SearchEntitiesByListParamsCommand, } from "../protocols/Aws_restJson1";
 import { getSerdePlugin } from "@smithy/middleware-serde";
 import { Command as $Command } from "@smithy/smithy-client";
-import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
 export { $Command };
-export class SearchEntitiesByListParamsCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
-    }
-    resolveMiddleware(clientStack, configuration, options) {
-        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "WimCacheClient";
-        const commandName = "SearchEntitiesByListParamsCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
-            inputFilterSensitiveLog: (_) => _,
-            outputFilterSensitiveLog: (_) => _,
-            [SMITHY_CONTEXT_KEY]: {
-                service: "WimCache",
-                operation: "SearchEntitiesByListParams",
-            },
-        };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
-        return se_SearchEntitiesByListParamsCommand(input, context);
-    }
-    deserialize(output, context) {
-        return de_SearchEntitiesByListParamsCommand(output, context);
-    }
+export class SearchEntitiesByListParamsCommand extends $Command.classBuilder()
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+    ];
+})
+    .s("WimCache", "SearchEntitiesByListParams", {})
+    .n("WimCacheClient", "SearchEntitiesByListParamsCommand")
+    .f(void 0, void 0)
+    .ser(se_SearchEntitiesByListParamsCommand)
+    .de(de_SearchEntitiesByListParamsCommand)
+    .build() {
 }

package/dist-es/commands/SearchEntitiesByParamsCommand.js

@@ -1,37 +1,17 @@
 import { de_SearchEntitiesByParamsCommand, se_SearchEntitiesByParamsCommand, } from "../protocols/Aws_restJson1";
 import { getSerdePlugin } from "@smithy/middleware-serde";
 import { Command as $Command } from "@smithy/smithy-client";
-import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
 export { $Command };
-export class SearchEntitiesByParamsCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
-    }
-    resolveMiddleware(clientStack, configuration, options) {
-        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "WimCacheClient";
-        const commandName = "SearchEntitiesByParamsCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
-            inputFilterSensitiveLog: (_) => _,
-            outputFilterSensitiveLog: (_) => _,
-            [SMITHY_CONTEXT_KEY]: {
-                service: "WimCache",
-                operation: "SearchEntitiesByParams",
-            },
-        };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
-        return se_SearchEntitiesByParamsCommand(input, context);
-    }
-    deserialize(output, context) {
-        return de_SearchEntitiesByParamsCommand(output, context);
-    }
+export class SearchEntitiesByParamsCommand extends $Command.classBuilder()
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+    ];
+})
+    .s("WimCache", "SearchEntitiesByParams", {})
+    .n("WimCacheClient", "SearchEntitiesByParamsCommand")
+    .f(void 0, void 0)
+    .ser(se_SearchEntitiesByParamsCommand)
+    .de(de_SearchEntitiesByParamsCommand)
+    .build() {
 }

package/dist-es/commands/SyncCacheCommand.js

@@ -1,37 +1,17 @@
 import { de_SyncCacheCommand, se_SyncCacheCommand, } from "../protocols/Aws_restJson1";
 import { getSerdePlugin } from "@smithy/middleware-serde";
 import { Command as $Command } from "@smithy/smithy-client";
-import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
 export { $Command };
-export class SyncCacheCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
-    }
-    resolveMiddleware(clientStack, configuration, options) {
-        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "WimCacheClient";
-        const commandName = "SyncCacheCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
-            inputFilterSensitiveLog: (_) => _,
-            outputFilterSensitiveLog: (_) => _,
-            [SMITHY_CONTEXT_KEY]: {
-                service: "WimCache",
-                operation: "SyncCache",
-            },
-        };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
-        return se_SyncCacheCommand(input, context);
-    }
-    deserialize(output, context) {
-        return de_SyncCacheCommand(output, context);
-    }
+export class SyncCacheCommand extends $Command.classBuilder()
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+    ];
+})
+    .s("WimCache", "SyncCache", {})
+    .n("WimCacheClient", "SyncCacheCommand")
+    .f(void 0, void 0)
+    .ser(se_SyncCacheCommand)
+    .de(de_SyncCacheCommand)
+    .build() {
 }

package/dist-es/commands/UpdateEntitiesWeightCommand.js

@@ -0,0 +1,17 @@
+import { de_UpdateEntitiesWeightCommand, se_UpdateEntitiesWeightCommand, } from "../protocols/Aws_restJson1";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+export { $Command };
+export class UpdateEntitiesWeightCommand extends $Command.classBuilder()
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+    ];
+})
+    .s("WimCache", "UpdateEntitiesWeight", {})
+    .n("WimCacheClient", "UpdateEntitiesWeightCommand")
+    .f(void 0, void 0)
+    .ser(se_UpdateEntitiesWeightCommand)
+    .de(de_UpdateEntitiesWeightCommand)
+    .build() {
+}

package/dist-es/commands/index.js

@@ -4,3 +4,4 @@ export * from "./PutEntitiesToGeneralCacheCommand";
 export * from "./SearchEntitiesByListParamsCommand";
 export * from "./SearchEntitiesByParamsCommand";
 export * from "./SyncCacheCommand";
+export * from "./UpdateEntitiesWeightCommand";

package/dist-es/models/models_0.js

@@ -1,13 +1,25 @@
 import { WimCacheServiceException as __BaseException } from "./WimCacheServiceException";
 export class ValidationException extends __BaseException {
+    name = "ValidationException";
+    $fault = "client";
     constructor(opts) {
         super({
             name: "ValidationException",
             $fault: "client",
             ...opts
         });
-        this.name = "ValidationException";
-        this.$fault = "client";
         Object.setPrototypeOf(this, ValidationException.prototype);
     }
 }
+export class ForbiddenException extends __BaseException {
+    name = "ForbiddenException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ForbiddenException",
+            $fault: "client",
+            ...opts
+        });
+        Object.setPrototypeOf(this, ForbiddenException.prototype);
+    }
+}