DMleadgen
46d973904b
Next.js website for Rocky Mountain Vending company featuring: - Product catalog with Stripe integration - Service areas and parts pages - Admin dashboard with Clerk authentication - SEO optimized pages with JSON-LD structured data Co-authored-by: Cursor <cursoragent@cursor.com>
299 lines
13 KiB
Text
299 lines
13 KiB
Text
'use strict';
|
|
|
|
var protocolHttp = require('@smithy/protocol-http');
|
|
var core = require('@smithy/core');
|
|
var propertyProvider = require('@smithy/property-provider');
|
|
var client = require('@aws-sdk/core/client');
|
|
var signatureV4 = require('@smithy/signature-v4');
|
|
|
|
const getDateHeader = (response) => protocolHttp.HttpResponse.isInstance(response) ? response.headers?.date ?? response.headers?.Date : undefined;
|
|
|
|
const getSkewCorrectedDate = (systemClockOffset) => new Date(Date.now() + systemClockOffset);
|
|
|
|
const isClockSkewed = (clockTime, systemClockOffset) => Math.abs(getSkewCorrectedDate(systemClockOffset).getTime() - clockTime) >= 300000;
|
|
|
|
const getUpdatedSystemClockOffset = (clockTime, currentSystemClockOffset) => {
|
|
const clockTimeInMs = Date.parse(clockTime);
|
|
if (isClockSkewed(clockTimeInMs, currentSystemClockOffset)) {
|
|
return clockTimeInMs - Date.now();
|
|
}
|
|
return currentSystemClockOffset;
|
|
};
|
|
|
|
const throwSigningPropertyError = (name, property) => {
|
|
if (!property) {
|
|
throw new Error(`Property \`${name}\` is not resolved for AWS SDK SigV4Auth`);
|
|
}
|
|
return property;
|
|
};
|
|
const validateSigningProperties = async (signingProperties) => {
|
|
const context = throwSigningPropertyError("context", signingProperties.context);
|
|
const config = throwSigningPropertyError("config", signingProperties.config);
|
|
const authScheme = context.endpointV2?.properties?.authSchemes?.[0];
|
|
const signerFunction = throwSigningPropertyError("signer", config.signer);
|
|
const signer = await signerFunction(authScheme);
|
|
const signingRegion = signingProperties?.signingRegion;
|
|
const signingRegionSet = signingProperties?.signingRegionSet;
|
|
const signingName = signingProperties?.signingName;
|
|
return {
|
|
config,
|
|
signer,
|
|
signingRegion,
|
|
signingRegionSet,
|
|
signingName,
|
|
};
|
|
};
|
|
class AwsSdkSigV4Signer {
|
|
async sign(httpRequest, identity, signingProperties) {
|
|
if (!protocolHttp.HttpRequest.isInstance(httpRequest)) {
|
|
throw new Error("The request is not an instance of `HttpRequest` and cannot be signed");
|
|
}
|
|
const validatedProps = await validateSigningProperties(signingProperties);
|
|
const { config, signer } = validatedProps;
|
|
let { signingRegion, signingName } = validatedProps;
|
|
const handlerExecutionContext = signingProperties.context;
|
|
if (handlerExecutionContext?.authSchemes?.length ?? 0 > 1) {
|
|
const [first, second] = handlerExecutionContext.authSchemes;
|
|
if (first?.name === "sigv4a" && second?.name === "sigv4") {
|
|
signingRegion = second?.signingRegion ?? signingRegion;
|
|
signingName = second?.signingName ?? signingName;
|
|
}
|
|
}
|
|
const signedRequest = await signer.sign(httpRequest, {
|
|
signingDate: getSkewCorrectedDate(config.systemClockOffset),
|
|
signingRegion: signingRegion,
|
|
signingService: signingName,
|
|
});
|
|
return signedRequest;
|
|
}
|
|
errorHandler(signingProperties) {
|
|
return (error) => {
|
|
const serverTime = error.ServerTime ?? getDateHeader(error.$response);
|
|
if (serverTime) {
|
|
const config = throwSigningPropertyError("config", signingProperties.config);
|
|
const initialSystemClockOffset = config.systemClockOffset;
|
|
config.systemClockOffset = getUpdatedSystemClockOffset(serverTime, config.systemClockOffset);
|
|
const clockSkewCorrected = config.systemClockOffset !== initialSystemClockOffset;
|
|
if (clockSkewCorrected && error.$metadata) {
|
|
error.$metadata.clockSkewCorrected = true;
|
|
}
|
|
}
|
|
throw error;
|
|
};
|
|
}
|
|
successHandler(httpResponse, signingProperties) {
|
|
const dateHeader = getDateHeader(httpResponse);
|
|
if (dateHeader) {
|
|
const config = throwSigningPropertyError("config", signingProperties.config);
|
|
config.systemClockOffset = getUpdatedSystemClockOffset(dateHeader, config.systemClockOffset);
|
|
}
|
|
}
|
|
}
|
|
const AWSSDKSigV4Signer = AwsSdkSigV4Signer;
|
|
|
|
class AwsSdkSigV4ASigner extends AwsSdkSigV4Signer {
|
|
async sign(httpRequest, identity, signingProperties) {
|
|
if (!protocolHttp.HttpRequest.isInstance(httpRequest)) {
|
|
throw new Error("The request is not an instance of `HttpRequest` and cannot be signed");
|
|
}
|
|
const { config, signer, signingRegion, signingRegionSet, signingName } = await validateSigningProperties(signingProperties);
|
|
const configResolvedSigningRegionSet = await config.sigv4aSigningRegionSet?.();
|
|
const multiRegionOverride = (configResolvedSigningRegionSet ??
|
|
signingRegionSet ?? [signingRegion]).join(",");
|
|
const signedRequest = await signer.sign(httpRequest, {
|
|
signingDate: getSkewCorrectedDate(config.systemClockOffset),
|
|
signingRegion: multiRegionOverride,
|
|
signingService: signingName,
|
|
});
|
|
return signedRequest;
|
|
}
|
|
}
|
|
|
|
const getArrayForCommaSeparatedString = (str) => typeof str === "string" && str.length > 0 ? str.split(",").map((item) => item.trim()) : [];
|
|
|
|
const getBearerTokenEnvKey = (signingName) => `AWS_BEARER_TOKEN_${signingName.replace(/[\s-]/g, "_").toUpperCase()}`;
|
|
|
|
const NODE_AUTH_SCHEME_PREFERENCE_ENV_KEY = "AWS_AUTH_SCHEME_PREFERENCE";
|
|
const NODE_AUTH_SCHEME_PREFERENCE_CONFIG_KEY = "auth_scheme_preference";
|
|
const NODE_AUTH_SCHEME_PREFERENCE_OPTIONS = {
|
|
environmentVariableSelector: (env, options) => {
|
|
if (options?.signingName) {
|
|
const bearerTokenKey = getBearerTokenEnvKey(options.signingName);
|
|
if (bearerTokenKey in env)
|
|
return ["httpBearerAuth"];
|
|
}
|
|
if (!(NODE_AUTH_SCHEME_PREFERENCE_ENV_KEY in env))
|
|
return undefined;
|
|
return getArrayForCommaSeparatedString(env[NODE_AUTH_SCHEME_PREFERENCE_ENV_KEY]);
|
|
},
|
|
configFileSelector: (profile) => {
|
|
if (!(NODE_AUTH_SCHEME_PREFERENCE_CONFIG_KEY in profile))
|
|
return undefined;
|
|
return getArrayForCommaSeparatedString(profile[NODE_AUTH_SCHEME_PREFERENCE_CONFIG_KEY]);
|
|
},
|
|
default: [],
|
|
};
|
|
|
|
const resolveAwsSdkSigV4AConfig = (config) => {
|
|
config.sigv4aSigningRegionSet = core.normalizeProvider(config.sigv4aSigningRegionSet);
|
|
return config;
|
|
};
|
|
const NODE_SIGV4A_CONFIG_OPTIONS = {
|
|
environmentVariableSelector(env) {
|
|
if (env.AWS_SIGV4A_SIGNING_REGION_SET) {
|
|
return env.AWS_SIGV4A_SIGNING_REGION_SET.split(",").map((_) => _.trim());
|
|
}
|
|
throw new propertyProvider.ProviderError("AWS_SIGV4A_SIGNING_REGION_SET not set in env.", {
|
|
tryNextLink: true,
|
|
});
|
|
},
|
|
configFileSelector(profile) {
|
|
if (profile.sigv4a_signing_region_set) {
|
|
return (profile.sigv4a_signing_region_set ?? "").split(",").map((_) => _.trim());
|
|
}
|
|
throw new propertyProvider.ProviderError("sigv4a_signing_region_set not set in profile.", {
|
|
tryNextLink: true,
|
|
});
|
|
},
|
|
default: undefined,
|
|
};
|
|
|
|
const resolveAwsSdkSigV4Config = (config) => {
|
|
let inputCredentials = config.credentials;
|
|
let isUserSupplied = !!config.credentials;
|
|
let resolvedCredentials = undefined;
|
|
Object.defineProperty(config, "credentials", {
|
|
set(credentials) {
|
|
if (credentials && credentials !== inputCredentials && credentials !== resolvedCredentials) {
|
|
isUserSupplied = true;
|
|
}
|
|
inputCredentials = credentials;
|
|
const memoizedProvider = normalizeCredentialProvider(config, {
|
|
credentials: inputCredentials,
|
|
credentialDefaultProvider: config.credentialDefaultProvider,
|
|
});
|
|
const boundProvider = bindCallerConfig(config, memoizedProvider);
|
|
if (isUserSupplied && !boundProvider.attributed) {
|
|
resolvedCredentials = async (options) => boundProvider(options).then((creds) => client.setCredentialFeature(creds, "CREDENTIALS_CODE", "e"));
|
|
resolvedCredentials.memoized = boundProvider.memoized;
|
|
resolvedCredentials.configBound = boundProvider.configBound;
|
|
resolvedCredentials.attributed = true;
|
|
}
|
|
else {
|
|
resolvedCredentials = boundProvider;
|
|
}
|
|
},
|
|
get() {
|
|
return resolvedCredentials;
|
|
},
|
|
enumerable: true,
|
|
configurable: true,
|
|
});
|
|
config.credentials = inputCredentials;
|
|
const { signingEscapePath = true, systemClockOffset = config.systemClockOffset || 0, sha256, } = config;
|
|
let signer;
|
|
if (config.signer) {
|
|
signer = core.normalizeProvider(config.signer);
|
|
}
|
|
else if (config.regionInfoProvider) {
|
|
signer = () => core.normalizeProvider(config.region)()
|
|
.then(async (region) => [
|
|
(await config.regionInfoProvider(region, {
|
|
useFipsEndpoint: await config.useFipsEndpoint(),
|
|
useDualstackEndpoint: await config.useDualstackEndpoint(),
|
|
})) || {},
|
|
region,
|
|
])
|
|
.then(([regionInfo, region]) => {
|
|
const { signingRegion, signingService } = regionInfo;
|
|
config.signingRegion = config.signingRegion || signingRegion || region;
|
|
config.signingName = config.signingName || signingService || config.serviceId;
|
|
const params = {
|
|
...config,
|
|
credentials: config.credentials,
|
|
region: config.signingRegion,
|
|
service: config.signingName,
|
|
sha256,
|
|
uriEscapePath: signingEscapePath,
|
|
};
|
|
const SignerCtor = config.signerConstructor || signatureV4.SignatureV4;
|
|
return new SignerCtor(params);
|
|
});
|
|
}
|
|
else {
|
|
signer = async (authScheme) => {
|
|
authScheme = Object.assign({}, {
|
|
name: "sigv4",
|
|
signingName: config.signingName || config.defaultSigningName,
|
|
signingRegion: await core.normalizeProvider(config.region)(),
|
|
properties: {},
|
|
}, authScheme);
|
|
const signingRegion = authScheme.signingRegion;
|
|
const signingService = authScheme.signingName;
|
|
config.signingRegion = config.signingRegion || signingRegion;
|
|
config.signingName = config.signingName || signingService || config.serviceId;
|
|
const params = {
|
|
...config,
|
|
credentials: config.credentials,
|
|
region: config.signingRegion,
|
|
service: config.signingName,
|
|
sha256,
|
|
uriEscapePath: signingEscapePath,
|
|
};
|
|
const SignerCtor = config.signerConstructor || signatureV4.SignatureV4;
|
|
return new SignerCtor(params);
|
|
};
|
|
}
|
|
const resolvedConfig = Object.assign(config, {
|
|
systemClockOffset,
|
|
signingEscapePath,
|
|
signer,
|
|
});
|
|
return resolvedConfig;
|
|
};
|
|
const resolveAWSSDKSigV4Config = resolveAwsSdkSigV4Config;
|
|
function normalizeCredentialProvider(config, { credentials, credentialDefaultProvider, }) {
|
|
let credentialsProvider;
|
|
if (credentials) {
|
|
if (!credentials?.memoized) {
|
|
credentialsProvider = core.memoizeIdentityProvider(credentials, core.isIdentityExpired, core.doesIdentityRequireRefresh);
|
|
}
|
|
else {
|
|
credentialsProvider = credentials;
|
|
}
|
|
}
|
|
else {
|
|
if (credentialDefaultProvider) {
|
|
credentialsProvider = core.normalizeProvider(credentialDefaultProvider(Object.assign({}, config, {
|
|
parentClientConfig: config,
|
|
})));
|
|
}
|
|
else {
|
|
credentialsProvider = async () => {
|
|
throw new Error("@aws-sdk/core::resolveAwsSdkSigV4Config - `credentials` not provided and no credentialDefaultProvider was configured.");
|
|
};
|
|
}
|
|
}
|
|
credentialsProvider.memoized = true;
|
|
return credentialsProvider;
|
|
}
|
|
function bindCallerConfig(config, credentialsProvider) {
|
|
if (credentialsProvider.configBound) {
|
|
return credentialsProvider;
|
|
}
|
|
const fn = async (options) => credentialsProvider({ ...options, callerClientConfig: config });
|
|
fn.memoized = credentialsProvider.memoized;
|
|
fn.configBound = true;
|
|
return fn;
|
|
}
|
|
|
|
exports.AWSSDKSigV4Signer = AWSSDKSigV4Signer;
|
|
exports.AwsSdkSigV4ASigner = AwsSdkSigV4ASigner;
|
|
exports.AwsSdkSigV4Signer = AwsSdkSigV4Signer;
|
|
exports.NODE_AUTH_SCHEME_PREFERENCE_OPTIONS = NODE_AUTH_SCHEME_PREFERENCE_OPTIONS;
|
|
exports.NODE_SIGV4A_CONFIG_OPTIONS = NODE_SIGV4A_CONFIG_OPTIONS;
|
|
exports.getBearerTokenEnvKey = getBearerTokenEnvKey;
|
|
exports.resolveAWSSDKSigV4Config = resolveAWSSDKSigV4Config;
|
|
exports.resolveAwsSdkSigV4AConfig = resolveAwsSdkSigV4AConfig;
|
|
exports.resolveAwsSdkSigV4Config = resolveAwsSdkSigV4Config;
|
|
exports.validateSigningProperties = validateSigningProperties;
|