@smithy/core
Advanced tools
Comparing version 1.2.2 to 1.3.0
@@ -1,6 +0,1 @@ | ||
"use strict"; | ||
Object.defineProperty(exports, "__esModule", { value: true }); | ||
exports.getSmithyContext = void 0; | ||
const types_1 = require("@smithy/types"); | ||
const getSmithyContext = (context) => context[types_1.SMITHY_CONTEXT_KEY] || (context[types_1.SMITHY_CONTEXT_KEY] = {}); | ||
exports.getSmithyContext = getSmithyContext; | ||
module.exports = require("./index.js"); |
@@ -1,12 +0,480 @@ | ||
"use strict"; | ||
Object.defineProperty(exports, "__esModule", { value: true }); | ||
exports.createPaginator = void 0; | ||
const tslib_1 = require("tslib"); | ||
tslib_1.__exportStar(require("./middleware-http-auth-scheme"), exports); | ||
tslib_1.__exportStar(require("./middleware-http-signing"), exports); | ||
tslib_1.__exportStar(require("./util-identity-and-auth"), exports); | ||
tslib_1.__exportStar(require("./getSmithyContext"), exports); | ||
tslib_1.__exportStar(require("./normalizeProvider"), exports); | ||
tslib_1.__exportStar(require("./protocols/requestBuilder"), exports); | ||
var createPaginator_1 = require("./pagination/createPaginator"); | ||
Object.defineProperty(exports, "createPaginator", { enumerable: true, get: function () { return createPaginator_1.createPaginator; } }); | ||
var __defProp = Object.defineProperty; | ||
var __getOwnPropDesc = Object.getOwnPropertyDescriptor; | ||
var __getOwnPropNames = Object.getOwnPropertyNames; | ||
var __hasOwnProp = Object.prototype.hasOwnProperty; | ||
var __name = (target, value) => __defProp(target, "name", { value, configurable: true }); | ||
var __export = (target, all) => { | ||
for (var name in all) | ||
__defProp(target, name, { get: all[name], enumerable: true }); | ||
}; | ||
var __copyProps = (to, from, except, desc) => { | ||
if (from && typeof from === "object" || typeof from === "function") { | ||
for (let key of __getOwnPropNames(from)) | ||
if (!__hasOwnProp.call(to, key) && key !== except) | ||
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); | ||
} | ||
return to; | ||
}; | ||
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod); | ||
// src/index.ts | ||
var src_exports = {}; | ||
__export(src_exports, { | ||
DefaultIdentityProviderConfig: () => DefaultIdentityProviderConfig, | ||
EXPIRATION_MS: () => EXPIRATION_MS, | ||
HttpApiKeyAuthSigner: () => HttpApiKeyAuthSigner, | ||
HttpBearerAuthSigner: () => HttpBearerAuthSigner, | ||
NoAuthSigner: () => NoAuthSigner, | ||
RequestBuilder: () => RequestBuilder, | ||
createIsIdentityExpiredFunction: () => createIsIdentityExpiredFunction, | ||
createPaginator: () => createPaginator, | ||
doesIdentityRequireRefresh: () => doesIdentityRequireRefresh, | ||
getHttpAuthSchemeEndpointRuleSetPlugin: () => getHttpAuthSchemeEndpointRuleSetPlugin, | ||
getHttpAuthSchemePlugin: () => getHttpAuthSchemePlugin, | ||
getHttpSigningPlugin: () => getHttpSigningPlugin, | ||
getSmithyContext: () => getSmithyContext3, | ||
httpAuthSchemeEndpointRuleSetMiddlewareOptions: () => httpAuthSchemeEndpointRuleSetMiddlewareOptions, | ||
httpAuthSchemeMiddleware: () => httpAuthSchemeMiddleware, | ||
httpAuthSchemeMiddlewareOptions: () => httpAuthSchemeMiddlewareOptions, | ||
httpSigningMiddleware: () => httpSigningMiddleware, | ||
httpSigningMiddlewareOptions: () => httpSigningMiddlewareOptions, | ||
isIdentityExpired: () => isIdentityExpired, | ||
memoizeIdentityProvider: () => memoizeIdentityProvider, | ||
normalizeProvider: () => normalizeProvider, | ||
requestBuilder: () => requestBuilder | ||
}); | ||
module.exports = __toCommonJS(src_exports); | ||
// src/middleware-http-auth-scheme/httpAuthSchemeMiddleware.ts | ||
var import_util_middleware = require("@smithy/util-middleware"); | ||
function convertHttpAuthSchemesToMap(httpAuthSchemes) { | ||
const map = /* @__PURE__ */ new Map(); | ||
for (const scheme of httpAuthSchemes) { | ||
map.set(scheme.schemeId, scheme); | ||
} | ||
return map; | ||
} | ||
__name(convertHttpAuthSchemesToMap, "convertHttpAuthSchemesToMap"); | ||
var httpAuthSchemeMiddleware = /* @__PURE__ */ __name((config, mwOptions) => (next, context) => async (args) => { | ||
var _a; | ||
const options = config.httpAuthSchemeProvider( | ||
await mwOptions.httpAuthSchemeParametersProvider(config, context, args.input) | ||
); | ||
const authSchemes = convertHttpAuthSchemesToMap(config.httpAuthSchemes); | ||
const smithyContext = (0, import_util_middleware.getSmithyContext)(context); | ||
const failureReasons = []; | ||
for (const option of options) { | ||
const scheme = authSchemes.get(option.schemeId); | ||
if (!scheme) { | ||
failureReasons.push(`HttpAuthScheme \`${option.schemeId}\` was not enabled for this service.`); | ||
continue; | ||
} | ||
const identityProvider = scheme.identityProvider(await mwOptions.identityProviderConfigProvider(config)); | ||
if (!identityProvider) { | ||
failureReasons.push(`HttpAuthScheme \`${option.schemeId}\` did not have an IdentityProvider configured.`); | ||
continue; | ||
} | ||
const { identityProperties = {}, signingProperties = {} } = ((_a = option.propertiesExtractor) == null ? void 0 : _a.call(option, config, context)) || {}; | ||
option.identityProperties = Object.assign(option.identityProperties || {}, identityProperties); | ||
option.signingProperties = Object.assign(option.signingProperties || {}, signingProperties); | ||
smithyContext.selectedHttpAuthScheme = { | ||
httpAuthOption: option, | ||
identity: await identityProvider(option.identityProperties), | ||
signer: scheme.signer | ||
}; | ||
break; | ||
} | ||
if (!smithyContext.selectedHttpAuthScheme) { | ||
throw new Error(failureReasons.join("\n")); | ||
} | ||
return next(args); | ||
}, "httpAuthSchemeMiddleware"); | ||
// src/middleware-http-auth-scheme/getHttpAuthSchemeEndpointRuleSetPlugin.ts | ||
var import_middleware_endpoint = require("@smithy/middleware-endpoint"); | ||
var httpAuthSchemeEndpointRuleSetMiddlewareOptions = { | ||
step: "serialize", | ||
tags: ["HTTP_AUTH_SCHEME"], | ||
name: "httpAuthSchemeMiddleware", | ||
override: true, | ||
relation: "before", | ||
toMiddleware: import_middleware_endpoint.endpointMiddlewareOptions.name | ||
}; | ||
var getHttpAuthSchemeEndpointRuleSetPlugin = /* @__PURE__ */ __name((config, { | ||
httpAuthSchemeParametersProvider, | ||
identityProviderConfigProvider | ||
}) => ({ | ||
applyToStack: (clientStack) => { | ||
clientStack.addRelativeTo( | ||
httpAuthSchemeMiddleware(config, { | ||
httpAuthSchemeParametersProvider, | ||
identityProviderConfigProvider | ||
}), | ||
httpAuthSchemeEndpointRuleSetMiddlewareOptions | ||
); | ||
} | ||
}), "getHttpAuthSchemeEndpointRuleSetPlugin"); | ||
// src/middleware-http-auth-scheme/getHttpAuthSchemePlugin.ts | ||
var import_middleware_serde = require("@smithy/middleware-serde"); | ||
var httpAuthSchemeMiddlewareOptions = { | ||
step: "serialize", | ||
tags: ["HTTP_AUTH_SCHEME"], | ||
name: "httpAuthSchemeMiddleware", | ||
override: true, | ||
relation: "before", | ||
toMiddleware: import_middleware_serde.serializerMiddlewareOption.name | ||
}; | ||
var getHttpAuthSchemePlugin = /* @__PURE__ */ __name((config, { | ||
httpAuthSchemeParametersProvider, | ||
identityProviderConfigProvider | ||
}) => ({ | ||
applyToStack: (clientStack) => { | ||
clientStack.addRelativeTo( | ||
httpAuthSchemeMiddleware(config, { | ||
httpAuthSchemeParametersProvider, | ||
identityProviderConfigProvider | ||
}), | ||
httpAuthSchemeMiddlewareOptions | ||
); | ||
} | ||
}), "getHttpAuthSchemePlugin"); | ||
// src/middleware-http-signing/httpSigningMiddleware.ts | ||
var import_protocol_http = require("@smithy/protocol-http"); | ||
var defaultErrorHandler = /* @__PURE__ */ __name((signingProperties) => (error) => { | ||
throw error; | ||
}, "defaultErrorHandler"); | ||
var defaultSuccessHandler = /* @__PURE__ */ __name((httpResponse, signingProperties) => { | ||
}, "defaultSuccessHandler"); | ||
var httpSigningMiddleware = /* @__PURE__ */ __name((config) => (next, context) => async (args) => { | ||
if (!import_protocol_http.HttpRequest.isInstance(args.request)) { | ||
return next(args); | ||
} | ||
const smithyContext = (0, import_util_middleware.getSmithyContext)(context); | ||
const scheme = smithyContext.selectedHttpAuthScheme; | ||
if (!scheme) { | ||
throw new Error(`No HttpAuthScheme was selected: unable to sign request`); | ||
} | ||
const { | ||
httpAuthOption: { signingProperties = {} }, | ||
identity, | ||
signer | ||
} = scheme; | ||
const output = await next({ | ||
...args, | ||
request: await signer.sign(args.request, identity, signingProperties) | ||
}).catch((signer.errorHandler || defaultErrorHandler)(signingProperties)); | ||
(signer.successHandler || defaultSuccessHandler)(output.response, signingProperties); | ||
return output; | ||
}, "httpSigningMiddleware"); | ||
// src/middleware-http-signing/getHttpSigningMiddleware.ts | ||
var import_middleware_retry = require("@smithy/middleware-retry"); | ||
var httpSigningMiddlewareOptions = { | ||
step: "finalizeRequest", | ||
tags: ["HTTP_SIGNING"], | ||
name: "httpSigningMiddleware", | ||
aliases: ["apiKeyMiddleware", "tokenMiddleware", "awsAuthMiddleware"], | ||
override: true, | ||
relation: "after", | ||
toMiddleware: import_middleware_retry.retryMiddlewareOptions.name | ||
}; | ||
var getHttpSigningPlugin = /* @__PURE__ */ __name((config) => ({ | ||
applyToStack: (clientStack) => { | ||
clientStack.addRelativeTo(httpSigningMiddleware(config), httpSigningMiddlewareOptions); | ||
} | ||
}), "getHttpSigningPlugin"); | ||
// src/util-identity-and-auth/DefaultIdentityProviderConfig.ts | ||
var _DefaultIdentityProviderConfig = class _DefaultIdentityProviderConfig { | ||
/** | ||
* Creates an IdentityProviderConfig with a record of scheme IDs to identity providers. | ||
* | ||
* @param config scheme IDs and identity providers to configure | ||
*/ | ||
constructor(config) { | ||
this.authSchemes = /* @__PURE__ */ new Map(); | ||
for (const [key, value] of Object.entries(config)) { | ||
if (value !== void 0) { | ||
this.authSchemes.set(key, value); | ||
} | ||
} | ||
} | ||
getIdentityProvider(schemeId) { | ||
return this.authSchemes.get(schemeId); | ||
} | ||
}; | ||
__name(_DefaultIdentityProviderConfig, "DefaultIdentityProviderConfig"); | ||
var DefaultIdentityProviderConfig = _DefaultIdentityProviderConfig; | ||
// src/util-identity-and-auth/httpAuthSchemes/httpApiKeyAuth.ts | ||
var import_types = require("@smithy/types"); | ||
var _HttpApiKeyAuthSigner = class _HttpApiKeyAuthSigner { | ||
async sign(httpRequest, identity, signingProperties) { | ||
if (!signingProperties) { | ||
throw new Error( | ||
"request could not be signed with `apiKey` since the `name` and `in` signer properties are missing" | ||
); | ||
} | ||
if (!signingProperties.name) { | ||
throw new Error("request could not be signed with `apiKey` since the `name` signer property is missing"); | ||
} | ||
if (!signingProperties.in) { | ||
throw new Error("request could not be signed with `apiKey` since the `in` signer property is missing"); | ||
} | ||
if (!identity.apiKey) { | ||
throw new Error("request could not be signed with `apiKey` since the `apiKey` is not defined"); | ||
} | ||
const clonedRequest = httpRequest.clone(); | ||
if (signingProperties.in === import_types.HttpApiKeyAuthLocation.QUERY) { | ||
clonedRequest.query[signingProperties.name] = identity.apiKey; | ||
} else if (signingProperties.in === import_types.HttpApiKeyAuthLocation.HEADER) { | ||
clonedRequest.headers[signingProperties.name] = signingProperties.scheme ? `${signingProperties.scheme} ${identity.apiKey}` : identity.apiKey; | ||
} else { | ||
throw new Error( | ||
"request can only be signed with `apiKey` locations `query` or `header`, but found: `" + signingProperties.in + "`" | ||
); | ||
} | ||
return clonedRequest; | ||
} | ||
}; | ||
__name(_HttpApiKeyAuthSigner, "HttpApiKeyAuthSigner"); | ||
var HttpApiKeyAuthSigner = _HttpApiKeyAuthSigner; | ||
// src/util-identity-and-auth/httpAuthSchemes/httpBearerAuth.ts | ||
var _HttpBearerAuthSigner = class _HttpBearerAuthSigner { | ||
async sign(httpRequest, identity, signingProperties) { | ||
const clonedRequest = httpRequest.clone(); | ||
if (!identity.token) { | ||
throw new Error("request could not be signed with `token` since the `token` is not defined"); | ||
} | ||
clonedRequest.headers["Authorization"] = `Bearer ${identity.token}`; | ||
return clonedRequest; | ||
} | ||
}; | ||
__name(_HttpBearerAuthSigner, "HttpBearerAuthSigner"); | ||
var HttpBearerAuthSigner = _HttpBearerAuthSigner; | ||
// src/util-identity-and-auth/httpAuthSchemes/noAuth.ts | ||
var _NoAuthSigner = class _NoAuthSigner { | ||
async sign(httpRequest, identity, signingProperties) { | ||
return httpRequest; | ||
} | ||
}; | ||
__name(_NoAuthSigner, "NoAuthSigner"); | ||
var NoAuthSigner = _NoAuthSigner; | ||
// src/util-identity-and-auth/memoizeIdentityProvider.ts | ||
var createIsIdentityExpiredFunction = /* @__PURE__ */ __name((expirationMs) => (identity) => doesIdentityRequireRefresh(identity) && identity.expiration.getTime() - Date.now() < expirationMs, "createIsIdentityExpiredFunction"); | ||
var EXPIRATION_MS = 3e5; | ||
var isIdentityExpired = createIsIdentityExpiredFunction(EXPIRATION_MS); | ||
var doesIdentityRequireRefresh = /* @__PURE__ */ __name((identity) => identity.expiration !== void 0, "doesIdentityRequireRefresh"); | ||
var memoizeIdentityProvider = /* @__PURE__ */ __name((provider, isExpired, requiresRefresh) => { | ||
if (provider === void 0) { | ||
return void 0; | ||
} | ||
const normalizedProvider = typeof provider !== "function" ? async () => Promise.resolve(provider) : provider; | ||
let resolved; | ||
let pending; | ||
let hasResult; | ||
let isConstant = false; | ||
const coalesceProvider = /* @__PURE__ */ __name(async (options) => { | ||
if (!pending) { | ||
pending = normalizedProvider(options); | ||
} | ||
try { | ||
resolved = await pending; | ||
hasResult = true; | ||
isConstant = false; | ||
} finally { | ||
pending = void 0; | ||
} | ||
return resolved; | ||
}, "coalesceProvider"); | ||
if (isExpired === void 0) { | ||
return async (options) => { | ||
if (!hasResult || (options == null ? void 0 : options.forceRefresh)) { | ||
resolved = await coalesceProvider(options); | ||
} | ||
return resolved; | ||
}; | ||
} | ||
return async (options) => { | ||
if (!hasResult || (options == null ? void 0 : options.forceRefresh)) { | ||
resolved = await coalesceProvider(options); | ||
} | ||
if (isConstant) { | ||
return resolved; | ||
} | ||
if (!requiresRefresh(resolved)) { | ||
isConstant = true; | ||
return resolved; | ||
} | ||
if (isExpired(resolved)) { | ||
await coalesceProvider(options); | ||
return resolved; | ||
} | ||
return resolved; | ||
}; | ||
}, "memoizeIdentityProvider"); | ||
// src/getSmithyContext.ts | ||
var getSmithyContext3 = /* @__PURE__ */ __name((context) => context[import_types.SMITHY_CONTEXT_KEY] || (context[import_types.SMITHY_CONTEXT_KEY] = {}), "getSmithyContext"); | ||
// src/normalizeProvider.ts | ||
var normalizeProvider = /* @__PURE__ */ __name((input) => { | ||
if (typeof input === "function") | ||
return input; | ||
const promisified = Promise.resolve(input); | ||
return () => promisified; | ||
}, "normalizeProvider"); | ||
// src/protocols/requestBuilder.ts | ||
var import_smithy_client = require("@smithy/smithy-client"); | ||
function requestBuilder(input, context) { | ||
return new RequestBuilder(input, context); | ||
} | ||
__name(requestBuilder, "requestBuilder"); | ||
var _RequestBuilder = class _RequestBuilder { | ||
constructor(input, context) { | ||
this.input = input; | ||
this.context = context; | ||
this.query = {}; | ||
this.method = ""; | ||
this.headers = {}; | ||
this.path = ""; | ||
this.body = null; | ||
this.hostname = ""; | ||
this.resolvePathStack = []; | ||
} | ||
async build() { | ||
const { hostname, protocol = "https", port, path: basePath } = await this.context.endpoint(); | ||
this.path = basePath; | ||
for (const resolvePath of this.resolvePathStack) { | ||
resolvePath(this.path); | ||
} | ||
return new import_protocol_http.HttpRequest({ | ||
protocol, | ||
hostname: this.hostname || hostname, | ||
port, | ||
method: this.method, | ||
path: this.path, | ||
query: this.query, | ||
body: this.body, | ||
headers: this.headers | ||
}); | ||
} | ||
/** | ||
* Brevity setter for "hostname". | ||
*/ | ||
hn(hostname) { | ||
this.hostname = hostname; | ||
return this; | ||
} | ||
/** | ||
* Brevity initial builder for "basepath". | ||
*/ | ||
bp(uriLabel) { | ||
this.resolvePathStack.push((basePath) => { | ||
this.path = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + uriLabel; | ||
}); | ||
return this; | ||
} | ||
/** | ||
* Brevity incremental builder for "path". | ||
*/ | ||
p(memberName, labelValueProvider, uriLabel, isGreedyLabel) { | ||
this.resolvePathStack.push((path) => { | ||
this.path = (0, import_smithy_client.resolvedPath)(path, this.input, memberName, labelValueProvider, uriLabel, isGreedyLabel); | ||
}); | ||
return this; | ||
} | ||
/** | ||
* Brevity setter for "headers". | ||
*/ | ||
h(headers) { | ||
this.headers = headers; | ||
return this; | ||
} | ||
/** | ||
* Brevity setter for "query". | ||
*/ | ||
q(query) { | ||
this.query = query; | ||
return this; | ||
} | ||
/** | ||
* Brevity setter for "body". | ||
*/ | ||
b(body) { | ||
this.body = body; | ||
return this; | ||
} | ||
/** | ||
* Brevity setter for "method". | ||
*/ | ||
m(method) { | ||
this.method = method; | ||
return this; | ||
} | ||
}; | ||
__name(_RequestBuilder, "RequestBuilder"); | ||
var RequestBuilder = _RequestBuilder; | ||
// src/pagination/createPaginator.ts | ||
var makePagedClientRequest = /* @__PURE__ */ __name(async (CommandCtor, client, input, ...args) => { | ||
return await client.send(new CommandCtor(input), ...args); | ||
}, "makePagedClientRequest"); | ||
function createPaginator(ClientCtor, CommandCtor, inputTokenName, outputTokenName, pageSizeTokenName) { | ||
return /* @__PURE__ */ __name(async function* paginateOperation(config, input, ...additionalArguments) { | ||
let token = config.startingToken || void 0; | ||
let hasNext = true; | ||
let page; | ||
while (hasNext) { | ||
input[inputTokenName] = token; | ||
if (pageSizeTokenName) { | ||
input[pageSizeTokenName] = input[pageSizeTokenName] ?? config.pageSize; | ||
} | ||
if (config.client instanceof ClientCtor) { | ||
page = await makePagedClientRequest(CommandCtor, config.client, input, ...additionalArguments); | ||
} else { | ||
throw new Error(`Invalid client, expected instance of ${ClientCtor.name}`); | ||
} | ||
yield page; | ||
const prevToken = token; | ||
token = page[outputTokenName]; | ||
hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken)); | ||
} | ||
return void 0; | ||
}, "paginateOperation"); | ||
} | ||
__name(createPaginator, "createPaginator"); | ||
// Annotate the CommonJS export names for ESM import in node: | ||
0 && (module.exports = { | ||
DefaultIdentityProviderConfig, | ||
EXPIRATION_MS, | ||
HttpApiKeyAuthSigner, | ||
HttpBearerAuthSigner, | ||
NoAuthSigner, | ||
RequestBuilder, | ||
createIsIdentityExpiredFunction, | ||
createPaginator, | ||
doesIdentityRequireRefresh, | ||
getHttpAuthSchemeEndpointRuleSetPlugin, | ||
getHttpAuthSchemePlugin, | ||
getHttpSigningPlugin, | ||
getSmithyContext, | ||
httpAuthSchemeEndpointRuleSetMiddlewareOptions, | ||
httpAuthSchemeMiddleware, | ||
httpAuthSchemeMiddlewareOptions, | ||
httpSigningMiddleware, | ||
httpSigningMiddlewareOptions, | ||
isIdentityExpired, | ||
memoizeIdentityProvider, | ||
normalizeProvider, | ||
requestBuilder | ||
}); |
@@ -1,22 +0,1 @@ | ||
"use strict"; | ||
Object.defineProperty(exports, "__esModule", { value: true }); | ||
exports.getHttpAuthSchemeEndpointRuleSetPlugin = exports.httpAuthSchemeEndpointRuleSetMiddlewareOptions = void 0; | ||
const middleware_endpoint_1 = require("@smithy/middleware-endpoint"); | ||
const httpAuthSchemeMiddleware_1 = require("./httpAuthSchemeMiddleware"); | ||
exports.httpAuthSchemeEndpointRuleSetMiddlewareOptions = { | ||
step: "serialize", | ||
tags: ["HTTP_AUTH_SCHEME"], | ||
name: "httpAuthSchemeMiddleware", | ||
override: true, | ||
relation: "before", | ||
toMiddleware: middleware_endpoint_1.endpointMiddlewareOptions.name, | ||
}; | ||
const getHttpAuthSchemeEndpointRuleSetPlugin = (config, { httpAuthSchemeParametersProvider, identityProviderConfigProvider, }) => ({ | ||
applyToStack: (clientStack) => { | ||
clientStack.addRelativeTo((0, httpAuthSchemeMiddleware_1.httpAuthSchemeMiddleware)(config, { | ||
httpAuthSchemeParametersProvider, | ||
identityProviderConfigProvider, | ||
}), exports.httpAuthSchemeEndpointRuleSetMiddlewareOptions); | ||
}, | ||
}); | ||
exports.getHttpAuthSchemeEndpointRuleSetPlugin = getHttpAuthSchemeEndpointRuleSetPlugin; | ||
module.exports = require("../index.js"); |
@@ -1,22 +0,1 @@ | ||
"use strict"; | ||
Object.defineProperty(exports, "__esModule", { value: true }); | ||
exports.getHttpAuthSchemePlugin = exports.httpAuthSchemeMiddlewareOptions = void 0; | ||
const middleware_serde_1 = require("@smithy/middleware-serde"); | ||
const httpAuthSchemeMiddleware_1 = require("./httpAuthSchemeMiddleware"); | ||
exports.httpAuthSchemeMiddlewareOptions = { | ||
step: "serialize", | ||
tags: ["HTTP_AUTH_SCHEME"], | ||
name: "httpAuthSchemeMiddleware", | ||
override: true, | ||
relation: "before", | ||
toMiddleware: middleware_serde_1.serializerMiddlewareOption.name, | ||
}; | ||
const getHttpAuthSchemePlugin = (config, { httpAuthSchemeParametersProvider, identityProviderConfigProvider, }) => ({ | ||
applyToStack: (clientStack) => { | ||
clientStack.addRelativeTo((0, httpAuthSchemeMiddleware_1.httpAuthSchemeMiddleware)(config, { | ||
httpAuthSchemeParametersProvider, | ||
identityProviderConfigProvider, | ||
}), exports.httpAuthSchemeMiddlewareOptions); | ||
}, | ||
}); | ||
exports.getHttpAuthSchemePlugin = getHttpAuthSchemePlugin; | ||
module.exports = require("../index.js"); |
@@ -1,45 +0,1 @@ | ||
"use strict"; | ||
Object.defineProperty(exports, "__esModule", { value: true }); | ||
exports.httpAuthSchemeMiddleware = void 0; | ||
const types_1 = require("@smithy/types"); | ||
const util_middleware_1 = require("@smithy/util-middleware"); | ||
function convertHttpAuthSchemesToMap(httpAuthSchemes) { | ||
const map = new Map(); | ||
for (const scheme of httpAuthSchemes) { | ||
map.set(scheme.schemeId, scheme); | ||
} | ||
return map; | ||
} | ||
const httpAuthSchemeMiddleware = (config, mwOptions) => (next, context) => async (args) => { | ||
var _a; | ||
const options = config.httpAuthSchemeProvider(await mwOptions.httpAuthSchemeParametersProvider(config, context, args.input)); | ||
const authSchemes = convertHttpAuthSchemesToMap(config.httpAuthSchemes); | ||
const smithyContext = (0, util_middleware_1.getSmithyContext)(context); | ||
const failureReasons = []; | ||
for (const option of options) { | ||
const scheme = authSchemes.get(option.schemeId); | ||
if (!scheme) { | ||
failureReasons.push(`HttpAuthScheme \`${option.schemeId}\` was not enabled for this service.`); | ||
continue; | ||
} | ||
const identityProvider = scheme.identityProvider(await mwOptions.identityProviderConfigProvider(config)); | ||
if (!identityProvider) { | ||
failureReasons.push(`HttpAuthScheme \`${option.schemeId}\` did not have an IdentityProvider configured.`); | ||
continue; | ||
} | ||
const { identityProperties = {}, signingProperties = {} } = ((_a = option.propertiesExtractor) === null || _a === void 0 ? void 0 : _a.call(option, config, context)) || {}; | ||
option.identityProperties = Object.assign(option.identityProperties || {}, identityProperties); | ||
option.signingProperties = Object.assign(option.signingProperties || {}, signingProperties); | ||
smithyContext.selectedHttpAuthScheme = { | ||
httpAuthOption: option, | ||
identity: await identityProvider(option.identityProperties), | ||
signer: scheme.signer, | ||
}; | ||
break; | ||
} | ||
if (!smithyContext.selectedHttpAuthScheme) { | ||
throw new Error(failureReasons.join("\n")); | ||
} | ||
return next(args); | ||
}; | ||
exports.httpAuthSchemeMiddleware = httpAuthSchemeMiddleware; | ||
module.exports = require("../index.js"); |
@@ -1,6 +0,1 @@ | ||
"use strict"; | ||
Object.defineProperty(exports, "__esModule", { value: true }); | ||
const tslib_1 = require("tslib"); | ||
tslib_1.__exportStar(require("./httpAuthSchemeMiddleware"), exports); | ||
tslib_1.__exportStar(require("./getHttpAuthSchemeEndpointRuleSetPlugin"), exports); | ||
tslib_1.__exportStar(require("./getHttpAuthSchemePlugin"), exports); | ||
module.exports = require("../index.js"); |
@@ -1,20 +0,1 @@ | ||
"use strict"; | ||
Object.defineProperty(exports, "__esModule", { value: true }); | ||
exports.getHttpSigningPlugin = exports.httpSigningMiddlewareOptions = void 0; | ||
const middleware_retry_1 = require("@smithy/middleware-retry"); | ||
const httpSigningMiddleware_1 = require("./httpSigningMiddleware"); | ||
exports.httpSigningMiddlewareOptions = { | ||
step: "finalizeRequest", | ||
tags: ["HTTP_SIGNING"], | ||
name: "httpSigningMiddleware", | ||
aliases: ["apiKeyMiddleware", "tokenMiddleware", "awsAuthMiddleware"], | ||
override: true, | ||
relation: "after", | ||
toMiddleware: middleware_retry_1.retryMiddlewareOptions.name, | ||
}; | ||
const getHttpSigningPlugin = (config) => ({ | ||
applyToStack: (clientStack) => { | ||
clientStack.addRelativeTo((0, httpSigningMiddleware_1.httpSigningMiddleware)(config), exports.httpSigningMiddlewareOptions); | ||
}, | ||
}); | ||
exports.getHttpSigningPlugin = getHttpSigningPlugin; | ||
module.exports = require("../index.js"); |
@@ -1,28 +0,1 @@ | ||
"use strict"; | ||
Object.defineProperty(exports, "__esModule", { value: true }); | ||
exports.httpSigningMiddleware = void 0; | ||
const protocol_http_1 = require("@smithy/protocol-http"); | ||
const types_1 = require("@smithy/types"); | ||
const util_middleware_1 = require("@smithy/util-middleware"); | ||
const defaultErrorHandler = (signingProperties) => (error) => { | ||
throw error; | ||
}; | ||
const defaultSuccessHandler = (httpResponse, signingProperties) => { }; | ||
const httpSigningMiddleware = (config) => (next, context) => async (args) => { | ||
if (!protocol_http_1.HttpRequest.isInstance(args.request)) { | ||
return next(args); | ||
} | ||
const smithyContext = (0, util_middleware_1.getSmithyContext)(context); | ||
const scheme = smithyContext.selectedHttpAuthScheme; | ||
if (!scheme) { | ||
throw new Error(`No HttpAuthScheme was selected: unable to sign request`); | ||
} | ||
const { httpAuthOption: { signingProperties = {} }, identity, signer, } = scheme; | ||
const output = await next({ | ||
...args, | ||
request: await signer.sign(args.request, identity, signingProperties), | ||
}).catch((signer.errorHandler || defaultErrorHandler)(signingProperties)); | ||
(signer.successHandler || defaultSuccessHandler)(output.response, signingProperties); | ||
return output; | ||
}; | ||
exports.httpSigningMiddleware = httpSigningMiddleware; | ||
module.exports = require("../index.js"); |
@@ -1,5 +0,1 @@ | ||
"use strict"; | ||
Object.defineProperty(exports, "__esModule", { value: true }); | ||
const tslib_1 = require("tslib"); | ||
tslib_1.__exportStar(require("./httpSigningMiddleware"), exports); | ||
tslib_1.__exportStar(require("./getHttpSigningMiddleware"), exports); | ||
module.exports = require("../index.js"); |
@@ -1,10 +0,1 @@ | ||
"use strict"; | ||
Object.defineProperty(exports, "__esModule", { value: true }); | ||
exports.normalizeProvider = void 0; | ||
const normalizeProvider = (input) => { | ||
if (typeof input === "function") | ||
return input; | ||
const promisified = Promise.resolve(input); | ||
return () => promisified; | ||
}; | ||
exports.normalizeProvider = normalizeProvider; | ||
module.exports = require("./index.js"); |
@@ -1,32 +0,1 @@ | ||
"use strict"; | ||
Object.defineProperty(exports, "__esModule", { value: true }); | ||
exports.createPaginator = void 0; | ||
const makePagedClientRequest = async (CommandCtor, client, input, ...args) => { | ||
return await client.send(new CommandCtor(input), ...args); | ||
}; | ||
function createPaginator(ClientCtor, CommandCtor, inputTokenName, outputTokenName, pageSizeTokenName) { | ||
return async function* paginateOperation(config, input, ...additionalArguments) { | ||
var _a; | ||
let token = config.startingToken || undefined; | ||
let hasNext = true; | ||
let page; | ||
while (hasNext) { | ||
input[inputTokenName] = token; | ||
if (pageSizeTokenName) { | ||
input[pageSizeTokenName] = (_a = input[pageSizeTokenName]) !== null && _a !== void 0 ? _a : config.pageSize; | ||
} | ||
if (config.client instanceof ClientCtor) { | ||
page = await makePagedClientRequest(CommandCtor, config.client, input, ...additionalArguments); | ||
} | ||
else { | ||
throw new Error(`Invalid client, expected instance of ${ClientCtor.name}`); | ||
} | ||
yield page; | ||
const prevToken = token; | ||
token = page[outputTokenName]; | ||
hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken)); | ||
} | ||
return undefined; | ||
}; | ||
} | ||
exports.createPaginator = createPaginator; | ||
module.exports = require("../index.js"); |
@@ -1,72 +0,1 @@ | ||
"use strict"; | ||
Object.defineProperty(exports, "__esModule", { value: true }); | ||
exports.RequestBuilder = exports.requestBuilder = void 0; | ||
const protocol_http_1 = require("@smithy/protocol-http"); | ||
const smithy_client_1 = require("@smithy/smithy-client"); | ||
function requestBuilder(input, context) { | ||
return new RequestBuilder(input, context); | ||
} | ||
exports.requestBuilder = requestBuilder; | ||
class RequestBuilder { | ||
constructor(input, context) { | ||
this.input = input; | ||
this.context = context; | ||
this.query = {}; | ||
this.method = ""; | ||
this.headers = {}; | ||
this.path = ""; | ||
this.body = null; | ||
this.hostname = ""; | ||
this.resolvePathStack = []; | ||
} | ||
async build() { | ||
const { hostname, protocol = "https", port, path: basePath } = await this.context.endpoint(); | ||
this.path = basePath; | ||
for (const resolvePath of this.resolvePathStack) { | ||
resolvePath(this.path); | ||
} | ||
return new protocol_http_1.HttpRequest({ | ||
protocol, | ||
hostname: this.hostname || hostname, | ||
port, | ||
method: this.method, | ||
path: this.path, | ||
query: this.query, | ||
body: this.body, | ||
headers: this.headers, | ||
}); | ||
} | ||
hn(hostname) { | ||
this.hostname = hostname; | ||
return this; | ||
} | ||
bp(uriLabel) { | ||
this.resolvePathStack.push((basePath) => { | ||
this.path = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + uriLabel; | ||
}); | ||
return this; | ||
} | ||
p(memberName, labelValueProvider, uriLabel, isGreedyLabel) { | ||
this.resolvePathStack.push((path) => { | ||
this.path = (0, smithy_client_1.resolvedPath)(path, this.input, memberName, labelValueProvider, uriLabel, isGreedyLabel); | ||
}); | ||
return this; | ||
} | ||
h(headers) { | ||
this.headers = headers; | ||
return this; | ||
} | ||
q(query) { | ||
this.query = query; | ||
return this; | ||
} | ||
b(body) { | ||
this.body = body; | ||
return this; | ||
} | ||
m(method) { | ||
this.method = method; | ||
return this; | ||
} | ||
} | ||
exports.RequestBuilder = RequestBuilder; | ||
module.exports = require("../index.js"); |
@@ -1,17 +0,1 @@ | ||
"use strict"; | ||
Object.defineProperty(exports, "__esModule", { value: true }); | ||
exports.DefaultIdentityProviderConfig = void 0; | ||
class DefaultIdentityProviderConfig { | ||
constructor(config) { | ||
this.authSchemes = new Map(); | ||
for (const [key, value] of Object.entries(config)) { | ||
if (value !== undefined) { | ||
this.authSchemes.set(key, value); | ||
} | ||
} | ||
} | ||
getIdentityProvider(schemeId) { | ||
return this.authSchemes.get(schemeId); | ||
} | ||
} | ||
exports.DefaultIdentityProviderConfig = DefaultIdentityProviderConfig; | ||
module.exports = require("../index.js"); |
@@ -1,37 +0,1 @@ | ||
"use strict"; | ||
Object.defineProperty(exports, "__esModule", { value: true }); | ||
exports.HttpApiKeyAuthSigner = void 0; | ||
const types_1 = require("@smithy/types"); | ||
class HttpApiKeyAuthSigner { | ||
async sign(httpRequest, identity, signingProperties) { | ||
if (!signingProperties) { | ||
throw new Error("request could not be signed with `apiKey` since the `name` and `in` signer properties are missing"); | ||
} | ||
if (!signingProperties.name) { | ||
throw new Error("request could not be signed with `apiKey` since the `name` signer property is missing"); | ||
} | ||
if (!signingProperties.in) { | ||
throw new Error("request could not be signed with `apiKey` since the `in` signer property is missing"); | ||
} | ||
if (!identity.apiKey) { | ||
throw new Error("request could not be signed with `apiKey` since the `apiKey` is not defined"); | ||
} | ||
const clonedRequest = httpRequest.clone(); | ||
if (signingProperties.in === types_1.HttpApiKeyAuthLocation.QUERY) { | ||
clonedRequest.query[signingProperties.name] = identity.apiKey; | ||
} | ||
else if (signingProperties.in === types_1.HttpApiKeyAuthLocation.HEADER) { | ||
clonedRequest.headers[signingProperties.name] = signingProperties.scheme | ||
? `${signingProperties.scheme} ${identity.apiKey}` | ||
: identity.apiKey; | ||
} | ||
else { | ||
throw new Error("request can only be signed with `apiKey` locations `query` or `header`, " + | ||
"but found: `" + | ||
signingProperties.in + | ||
"`"); | ||
} | ||
return clonedRequest; | ||
} | ||
} | ||
exports.HttpApiKeyAuthSigner = HttpApiKeyAuthSigner; | ||
module.exports = require("../../index.js"); |
@@ -1,14 +0,1 @@ | ||
"use strict"; | ||
Object.defineProperty(exports, "__esModule", { value: true }); | ||
exports.HttpBearerAuthSigner = void 0; | ||
class HttpBearerAuthSigner { | ||
async sign(httpRequest, identity, signingProperties) { | ||
const clonedRequest = httpRequest.clone(); | ||
if (!identity.token) { | ||
throw new Error("request could not be signed with `token` since the `token` is not defined"); | ||
} | ||
clonedRequest.headers["Authorization"] = `Bearer ${identity.token}`; | ||
return clonedRequest; | ||
} | ||
} | ||
exports.HttpBearerAuthSigner = HttpBearerAuthSigner; | ||
module.exports = require("../../index.js"); |
@@ -1,6 +0,1 @@ | ||
"use strict"; | ||
Object.defineProperty(exports, "__esModule", { value: true }); | ||
const tslib_1 = require("tslib"); | ||
tslib_1.__exportStar(require("./httpApiKeyAuth"), exports); | ||
tslib_1.__exportStar(require("./httpBearerAuth"), exports); | ||
tslib_1.__exportStar(require("./noAuth"), exports); | ||
module.exports = require("../../index.js"); |
@@ -1,9 +0,1 @@ | ||
"use strict"; | ||
Object.defineProperty(exports, "__esModule", { value: true }); | ||
exports.NoAuthSigner = void 0; | ||
class NoAuthSigner { | ||
async sign(httpRequest, identity, signingProperties) { | ||
return httpRequest; | ||
} | ||
} | ||
exports.NoAuthSigner = NoAuthSigner; | ||
module.exports = require("../../index.js"); |
@@ -1,6 +0,1 @@ | ||
"use strict"; | ||
Object.defineProperty(exports, "__esModule", { value: true }); | ||
const tslib_1 = require("tslib"); | ||
tslib_1.__exportStar(require("./DefaultIdentityProviderConfig"), exports); | ||
tslib_1.__exportStar(require("./httpAuthSchemes"), exports); | ||
tslib_1.__exportStar(require("./memoizeIdentityProvider"), exports); | ||
module.exports = require("../index.js"); |
@@ -1,59 +0,1 @@ | ||
"use strict"; | ||
Object.defineProperty(exports, "__esModule", { value: true }); | ||
exports.memoizeIdentityProvider = exports.doesIdentityRequireRefresh = exports.isIdentityExpired = exports.EXPIRATION_MS = exports.createIsIdentityExpiredFunction = void 0; | ||
const createIsIdentityExpiredFunction = (expirationMs) => (identity) => (0, exports.doesIdentityRequireRefresh)(identity) && identity.expiration.getTime() - Date.now() < expirationMs; | ||
exports.createIsIdentityExpiredFunction = createIsIdentityExpiredFunction; | ||
exports.EXPIRATION_MS = 300000; | ||
exports.isIdentityExpired = (0, exports.createIsIdentityExpiredFunction)(exports.EXPIRATION_MS); | ||
const doesIdentityRequireRefresh = (identity) => identity.expiration !== undefined; | ||
exports.doesIdentityRequireRefresh = doesIdentityRequireRefresh; | ||
const memoizeIdentityProvider = (provider, isExpired, requiresRefresh) => { | ||
if (provider === undefined) { | ||
return undefined; | ||
} | ||
const normalizedProvider = typeof provider !== "function" ? async () => Promise.resolve(provider) : provider; | ||
let resolved; | ||
let pending; | ||
let hasResult; | ||
let isConstant = false; | ||
const coalesceProvider = async (options) => { | ||
if (!pending) { | ||
pending = normalizedProvider(options); | ||
} | ||
try { | ||
resolved = await pending; | ||
hasResult = true; | ||
isConstant = false; | ||
} | ||
finally { | ||
pending = undefined; | ||
} | ||
return resolved; | ||
}; | ||
if (isExpired === undefined) { | ||
return async (options) => { | ||
if (!hasResult || (options === null || options === void 0 ? void 0 : options.forceRefresh)) { | ||
resolved = await coalesceProvider(options); | ||
} | ||
return resolved; | ||
}; | ||
} | ||
return async (options) => { | ||
if (!hasResult || (options === null || options === void 0 ? void 0 : options.forceRefresh)) { | ||
resolved = await coalesceProvider(options); | ||
} | ||
if (isConstant) { | ||
return resolved; | ||
} | ||
if (!requiresRefresh(resolved)) { | ||
isConstant = true; | ||
return resolved; | ||
} | ||
if (isExpired(resolved)) { | ||
await coalesceProvider(options); | ||
return resolved; | ||
} | ||
return resolved; | ||
}; | ||
}; | ||
exports.memoizeIdentityProvider = memoizeIdentityProvider; | ||
module.exports = require("../index.js"); |
{ | ||
"name": "@smithy/core", | ||
"version": "1.2.2", | ||
"version": "1.3.0", | ||
"scripts": { | ||
"build": "concurrently 'yarn:build:cjs' 'yarn:build:es' 'yarn:build:types && yarn build:types:downlevel'", | ||
"build:cjs": "yarn g:tsc -p tsconfig.cjs.json", | ||
"build:cjs": "node ../../scripts/inline core", | ||
"build:es": "yarn g:tsc -p tsconfig.es.json", | ||
@@ -26,9 +26,9 @@ "build:types": "yarn g:tsc -p tsconfig.types.json", | ||
"dependencies": { | ||
"@smithy/middleware-endpoint": "^2.3.0", | ||
"@smithy/middleware-retry": "^2.0.26", | ||
"@smithy/middleware-serde": "^2.0.16", | ||
"@smithy/protocol-http": "^3.0.12", | ||
"@smithy/smithy-client": "^2.2.1", | ||
"@smithy/types": "^2.8.0", | ||
"@smithy/util-middleware": "^2.0.9", | ||
"@smithy/middleware-endpoint": "^2.4.0", | ||
"@smithy/middleware-retry": "^2.1.0", | ||
"@smithy/middleware-serde": "^2.1.0", | ||
"@smithy/protocol-http": "^3.1.0", | ||
"@smithy/smithy-client": "^2.3.0", | ||
"@smithy/types": "^2.9.0", | ||
"@smithy/util-middleware": "^2.1.0", | ||
"tslib": "^2.5.0" | ||
@@ -35,0 +35,0 @@ }, |
License Policy Violation
LicenseThis package is not allowed per your license policy. Review the package's license to ensure compliance.
Found 1 instance in 1 package
License Policy Violation
LicenseThis package is not allowed per your license policy. Review the package's license to ensure compliance.
Found 1 instance in 1 package
1300
9
2
67096