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>
839 lines
33 KiB
Text
839 lines
33 KiB
Text
'use strict';
|
|
|
|
var utilStream = require('@smithy/util-stream');
|
|
var schema = require('@smithy/core/schema');
|
|
var serde = require('@smithy/core/serde');
|
|
var protocolHttp = require('@smithy/protocol-http');
|
|
var utilBase64 = require('@smithy/util-base64');
|
|
var utilUtf8 = require('@smithy/util-utf8');
|
|
|
|
const collectBody = async (streamBody = new Uint8Array(), context) => {
|
|
if (streamBody instanceof Uint8Array) {
|
|
return utilStream.Uint8ArrayBlobAdapter.mutate(streamBody);
|
|
}
|
|
if (!streamBody) {
|
|
return utilStream.Uint8ArrayBlobAdapter.mutate(new Uint8Array());
|
|
}
|
|
const fromContext = context.streamCollector(streamBody);
|
|
return utilStream.Uint8ArrayBlobAdapter.mutate(await fromContext);
|
|
};
|
|
|
|
function extendedEncodeURIComponent(str) {
|
|
return encodeURIComponent(str).replace(/[!'()*]/g, function (c) {
|
|
return "%" + c.charCodeAt(0).toString(16).toUpperCase();
|
|
});
|
|
}
|
|
|
|
class SerdeContext {
|
|
serdeContext;
|
|
setSerdeContext(serdeContext) {
|
|
this.serdeContext = serdeContext;
|
|
}
|
|
}
|
|
|
|
class HttpProtocol extends SerdeContext {
|
|
options;
|
|
constructor(options) {
|
|
super();
|
|
this.options = options;
|
|
}
|
|
getRequestType() {
|
|
return protocolHttp.HttpRequest;
|
|
}
|
|
getResponseType() {
|
|
return protocolHttp.HttpResponse;
|
|
}
|
|
setSerdeContext(serdeContext) {
|
|
this.serdeContext = serdeContext;
|
|
this.serializer.setSerdeContext(serdeContext);
|
|
this.deserializer.setSerdeContext(serdeContext);
|
|
if (this.getPayloadCodec()) {
|
|
this.getPayloadCodec().setSerdeContext(serdeContext);
|
|
}
|
|
}
|
|
updateServiceEndpoint(request, endpoint) {
|
|
if ("url" in endpoint) {
|
|
request.protocol = endpoint.url.protocol;
|
|
request.hostname = endpoint.url.hostname;
|
|
request.port = endpoint.url.port ? Number(endpoint.url.port) : undefined;
|
|
request.path = endpoint.url.pathname;
|
|
request.fragment = endpoint.url.hash || void 0;
|
|
request.username = endpoint.url.username || void 0;
|
|
request.password = endpoint.url.password || void 0;
|
|
if (!request.query) {
|
|
request.query = {};
|
|
}
|
|
for (const [k, v] of endpoint.url.searchParams.entries()) {
|
|
request.query[k] = v;
|
|
}
|
|
return request;
|
|
}
|
|
else {
|
|
request.protocol = endpoint.protocol;
|
|
request.hostname = endpoint.hostname;
|
|
request.port = endpoint.port ? Number(endpoint.port) : undefined;
|
|
request.path = endpoint.path;
|
|
request.query = {
|
|
...endpoint.query,
|
|
};
|
|
return request;
|
|
}
|
|
}
|
|
setHostPrefix(request, operationSchema, input) {
|
|
const inputNs = schema.NormalizedSchema.of(operationSchema.input);
|
|
const opTraits = schema.translateTraits(operationSchema.traits ?? {});
|
|
if (opTraits.endpoint) {
|
|
let hostPrefix = opTraits.endpoint?.[0];
|
|
if (typeof hostPrefix === "string") {
|
|
const hostLabelInputs = [...inputNs.structIterator()].filter(([, member]) => member.getMergedTraits().hostLabel);
|
|
for (const [name] of hostLabelInputs) {
|
|
const replacement = input[name];
|
|
if (typeof replacement !== "string") {
|
|
throw new Error(`@smithy/core/schema - ${name} in input must be a string as hostLabel.`);
|
|
}
|
|
hostPrefix = hostPrefix.replace(`{${name}}`, replacement);
|
|
}
|
|
request.hostname = hostPrefix + request.hostname;
|
|
}
|
|
}
|
|
}
|
|
deserializeMetadata(output) {
|
|
return {
|
|
httpStatusCode: output.statusCode,
|
|
requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
|
|
extendedRequestId: output.headers["x-amz-id-2"],
|
|
cfId: output.headers["x-amz-cf-id"],
|
|
};
|
|
}
|
|
async serializeEventStream({ eventStream, requestSchema, initialRequest, }) {
|
|
const eventStreamSerde = await this.loadEventStreamCapability();
|
|
return eventStreamSerde.serializeEventStream({
|
|
eventStream,
|
|
requestSchema,
|
|
initialRequest,
|
|
});
|
|
}
|
|
async deserializeEventStream({ response, responseSchema, initialResponseContainer, }) {
|
|
const eventStreamSerde = await this.loadEventStreamCapability();
|
|
return eventStreamSerde.deserializeEventStream({
|
|
response,
|
|
responseSchema,
|
|
initialResponseContainer,
|
|
});
|
|
}
|
|
async loadEventStreamCapability() {
|
|
const { EventStreamSerde } = await import('@smithy/core/event-streams');
|
|
return new EventStreamSerde({
|
|
marshaller: this.getEventStreamMarshaller(),
|
|
serializer: this.serializer,
|
|
deserializer: this.deserializer,
|
|
serdeContext: this.serdeContext,
|
|
defaultContentType: this.getDefaultContentType(),
|
|
});
|
|
}
|
|
getDefaultContentType() {
|
|
throw new Error(`@smithy/core/protocols - ${this.constructor.name} getDefaultContentType() implementation missing.`);
|
|
}
|
|
async deserializeHttpMessage(schema, context, response, arg4, arg5) {
|
|
return [];
|
|
}
|
|
getEventStreamMarshaller() {
|
|
const context = this.serdeContext;
|
|
if (!context.eventStreamMarshaller) {
|
|
throw new Error("@smithy/core - HttpProtocol: eventStreamMarshaller missing in serdeContext.");
|
|
}
|
|
return context.eventStreamMarshaller;
|
|
}
|
|
}
|
|
|
|
class HttpBindingProtocol extends HttpProtocol {
|
|
async serializeRequest(operationSchema, _input, context) {
|
|
const input = {
|
|
...(_input ?? {}),
|
|
};
|
|
const serializer = this.serializer;
|
|
const query = {};
|
|
const headers = {};
|
|
const endpoint = await context.endpoint();
|
|
const ns = schema.NormalizedSchema.of(operationSchema?.input);
|
|
const schema$1 = ns.getSchema();
|
|
let hasNonHttpBindingMember = false;
|
|
let payload;
|
|
const request = new protocolHttp.HttpRequest({
|
|
protocol: "",
|
|
hostname: "",
|
|
port: undefined,
|
|
path: "",
|
|
fragment: undefined,
|
|
query: query,
|
|
headers: headers,
|
|
body: undefined,
|
|
});
|
|
if (endpoint) {
|
|
this.updateServiceEndpoint(request, endpoint);
|
|
this.setHostPrefix(request, operationSchema, input);
|
|
const opTraits = schema.translateTraits(operationSchema.traits);
|
|
if (opTraits.http) {
|
|
request.method = opTraits.http[0];
|
|
const [path, search] = opTraits.http[1].split("?");
|
|
if (request.path == "/") {
|
|
request.path = path;
|
|
}
|
|
else {
|
|
request.path += path;
|
|
}
|
|
const traitSearchParams = new URLSearchParams(search ?? "");
|
|
Object.assign(query, Object.fromEntries(traitSearchParams));
|
|
}
|
|
}
|
|
for (const [memberName, memberNs] of ns.structIterator()) {
|
|
const memberTraits = memberNs.getMergedTraits() ?? {};
|
|
const inputMemberValue = input[memberName];
|
|
if (inputMemberValue == null && !memberNs.isIdempotencyToken()) {
|
|
continue;
|
|
}
|
|
if (memberTraits.httpPayload) {
|
|
const isStreaming = memberNs.isStreaming();
|
|
if (isStreaming) {
|
|
const isEventStream = memberNs.isStructSchema();
|
|
if (isEventStream) {
|
|
if (input[memberName]) {
|
|
payload = await this.serializeEventStream({
|
|
eventStream: input[memberName],
|
|
requestSchema: ns,
|
|
});
|
|
}
|
|
}
|
|
else {
|
|
payload = inputMemberValue;
|
|
}
|
|
}
|
|
else {
|
|
serializer.write(memberNs, inputMemberValue);
|
|
payload = serializer.flush();
|
|
}
|
|
delete input[memberName];
|
|
}
|
|
else if (memberTraits.httpLabel) {
|
|
serializer.write(memberNs, inputMemberValue);
|
|
const replacement = serializer.flush();
|
|
if (request.path.includes(`{${memberName}+}`)) {
|
|
request.path = request.path.replace(`{${memberName}+}`, replacement.split("/").map(extendedEncodeURIComponent).join("/"));
|
|
}
|
|
else if (request.path.includes(`{${memberName}}`)) {
|
|
request.path = request.path.replace(`{${memberName}}`, extendedEncodeURIComponent(replacement));
|
|
}
|
|
delete input[memberName];
|
|
}
|
|
else if (memberTraits.httpHeader) {
|
|
serializer.write(memberNs, inputMemberValue);
|
|
headers[memberTraits.httpHeader.toLowerCase()] = String(serializer.flush());
|
|
delete input[memberName];
|
|
}
|
|
else if (typeof memberTraits.httpPrefixHeaders === "string") {
|
|
for (const [key, val] of Object.entries(inputMemberValue)) {
|
|
const amalgam = memberTraits.httpPrefixHeaders + key;
|
|
serializer.write([memberNs.getValueSchema(), { httpHeader: amalgam }], val);
|
|
headers[amalgam.toLowerCase()] = serializer.flush();
|
|
}
|
|
delete input[memberName];
|
|
}
|
|
else if (memberTraits.httpQuery || memberTraits.httpQueryParams) {
|
|
this.serializeQuery(memberNs, inputMemberValue, query);
|
|
delete input[memberName];
|
|
}
|
|
else {
|
|
hasNonHttpBindingMember = true;
|
|
}
|
|
}
|
|
if (hasNonHttpBindingMember && input) {
|
|
serializer.write(schema$1, input);
|
|
payload = serializer.flush();
|
|
}
|
|
request.headers = headers;
|
|
request.query = query;
|
|
request.body = payload;
|
|
return request;
|
|
}
|
|
serializeQuery(ns, data, query) {
|
|
const serializer = this.serializer;
|
|
const traits = ns.getMergedTraits();
|
|
if (traits.httpQueryParams) {
|
|
for (const [key, val] of Object.entries(data)) {
|
|
if (!(key in query)) {
|
|
const valueSchema = ns.getValueSchema();
|
|
Object.assign(valueSchema.getMergedTraits(), {
|
|
...traits,
|
|
httpQuery: key,
|
|
httpQueryParams: undefined,
|
|
});
|
|
this.serializeQuery(valueSchema, val, query);
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
if (ns.isListSchema()) {
|
|
const sparse = !!ns.getMergedTraits().sparse;
|
|
const buffer = [];
|
|
for (const item of data) {
|
|
serializer.write([ns.getValueSchema(), traits], item);
|
|
const serializable = serializer.flush();
|
|
if (sparse || serializable !== undefined) {
|
|
buffer.push(serializable);
|
|
}
|
|
}
|
|
query[traits.httpQuery] = buffer;
|
|
}
|
|
else {
|
|
serializer.write([ns, traits], data);
|
|
query[traits.httpQuery] = serializer.flush();
|
|
}
|
|
}
|
|
async deserializeResponse(operationSchema, context, response) {
|
|
const deserializer = this.deserializer;
|
|
const ns = schema.NormalizedSchema.of(operationSchema.output);
|
|
const dataObject = {};
|
|
if (response.statusCode >= 300) {
|
|
const bytes = await collectBody(response.body, context);
|
|
if (bytes.byteLength > 0) {
|
|
Object.assign(dataObject, await deserializer.read(15, bytes));
|
|
}
|
|
await this.handleError(operationSchema, context, response, dataObject, this.deserializeMetadata(response));
|
|
throw new Error("@smithy/core/protocols - HTTP Protocol error handler failed to throw.");
|
|
}
|
|
for (const header in response.headers) {
|
|
const value = response.headers[header];
|
|
delete response.headers[header];
|
|
response.headers[header.toLowerCase()] = value;
|
|
}
|
|
const nonHttpBindingMembers = await this.deserializeHttpMessage(ns, context, response, dataObject);
|
|
if (nonHttpBindingMembers.length) {
|
|
const bytes = await collectBody(response.body, context);
|
|
if (bytes.byteLength > 0) {
|
|
const dataFromBody = await deserializer.read(ns, bytes);
|
|
for (const member of nonHttpBindingMembers) {
|
|
dataObject[member] = dataFromBody[member];
|
|
}
|
|
}
|
|
}
|
|
else if (nonHttpBindingMembers.discardResponseBody) {
|
|
await collectBody(response.body, context);
|
|
}
|
|
dataObject.$metadata = this.deserializeMetadata(response);
|
|
return dataObject;
|
|
}
|
|
async deserializeHttpMessage(schema$1, context, response, arg4, arg5) {
|
|
let dataObject;
|
|
if (arg4 instanceof Set) {
|
|
dataObject = arg5;
|
|
}
|
|
else {
|
|
dataObject = arg4;
|
|
}
|
|
let discardResponseBody = true;
|
|
const deserializer = this.deserializer;
|
|
const ns = schema.NormalizedSchema.of(schema$1);
|
|
const nonHttpBindingMembers = [];
|
|
for (const [memberName, memberSchema] of ns.structIterator()) {
|
|
const memberTraits = memberSchema.getMemberTraits();
|
|
if (memberTraits.httpPayload) {
|
|
discardResponseBody = false;
|
|
const isStreaming = memberSchema.isStreaming();
|
|
if (isStreaming) {
|
|
const isEventStream = memberSchema.isStructSchema();
|
|
if (isEventStream) {
|
|
dataObject[memberName] = await this.deserializeEventStream({
|
|
response,
|
|
responseSchema: ns,
|
|
});
|
|
}
|
|
else {
|
|
dataObject[memberName] = utilStream.sdkStreamMixin(response.body);
|
|
}
|
|
}
|
|
else if (response.body) {
|
|
const bytes = await collectBody(response.body, context);
|
|
if (bytes.byteLength > 0) {
|
|
dataObject[memberName] = await deserializer.read(memberSchema, bytes);
|
|
}
|
|
}
|
|
}
|
|
else if (memberTraits.httpHeader) {
|
|
const key = String(memberTraits.httpHeader).toLowerCase();
|
|
const value = response.headers[key];
|
|
if (null != value) {
|
|
if (memberSchema.isListSchema()) {
|
|
const headerListValueSchema = memberSchema.getValueSchema();
|
|
headerListValueSchema.getMergedTraits().httpHeader = key;
|
|
let sections;
|
|
if (headerListValueSchema.isTimestampSchema() &&
|
|
headerListValueSchema.getSchema() === 4) {
|
|
sections = serde.splitEvery(value, ",", 2);
|
|
}
|
|
else {
|
|
sections = serde.splitHeader(value);
|
|
}
|
|
const list = [];
|
|
for (const section of sections) {
|
|
list.push(await deserializer.read(headerListValueSchema, section.trim()));
|
|
}
|
|
dataObject[memberName] = list;
|
|
}
|
|
else {
|
|
dataObject[memberName] = await deserializer.read(memberSchema, value);
|
|
}
|
|
}
|
|
}
|
|
else if (memberTraits.httpPrefixHeaders !== undefined) {
|
|
dataObject[memberName] = {};
|
|
for (const [header, value] of Object.entries(response.headers)) {
|
|
if (header.startsWith(memberTraits.httpPrefixHeaders)) {
|
|
const valueSchema = memberSchema.getValueSchema();
|
|
valueSchema.getMergedTraits().httpHeader = header;
|
|
dataObject[memberName][header.slice(memberTraits.httpPrefixHeaders.length)] = await deserializer.read(valueSchema, value);
|
|
}
|
|
}
|
|
}
|
|
else if (memberTraits.httpResponseCode) {
|
|
dataObject[memberName] = response.statusCode;
|
|
}
|
|
else {
|
|
nonHttpBindingMembers.push(memberName);
|
|
}
|
|
}
|
|
nonHttpBindingMembers.discardResponseBody = discardResponseBody;
|
|
return nonHttpBindingMembers;
|
|
}
|
|
}
|
|
|
|
class RpcProtocol extends HttpProtocol {
|
|
async serializeRequest(operationSchema, input, context) {
|
|
const serializer = this.serializer;
|
|
const query = {};
|
|
const headers = {};
|
|
const endpoint = await context.endpoint();
|
|
const ns = schema.NormalizedSchema.of(operationSchema?.input);
|
|
const schema$1 = ns.getSchema();
|
|
let payload;
|
|
const request = new protocolHttp.HttpRequest({
|
|
protocol: "",
|
|
hostname: "",
|
|
port: undefined,
|
|
path: "/",
|
|
fragment: undefined,
|
|
query: query,
|
|
headers: headers,
|
|
body: undefined,
|
|
});
|
|
if (endpoint) {
|
|
this.updateServiceEndpoint(request, endpoint);
|
|
this.setHostPrefix(request, operationSchema, input);
|
|
}
|
|
const _input = {
|
|
...input,
|
|
};
|
|
if (input) {
|
|
const eventStreamMember = ns.getEventStreamMember();
|
|
if (eventStreamMember) {
|
|
if (_input[eventStreamMember]) {
|
|
const initialRequest = {};
|
|
for (const [memberName, memberSchema] of ns.structIterator()) {
|
|
if (memberName !== eventStreamMember && _input[memberName]) {
|
|
serializer.write(memberSchema, _input[memberName]);
|
|
initialRequest[memberName] = serializer.flush();
|
|
}
|
|
}
|
|
payload = await this.serializeEventStream({
|
|
eventStream: _input[eventStreamMember],
|
|
requestSchema: ns,
|
|
initialRequest,
|
|
});
|
|
}
|
|
}
|
|
else {
|
|
serializer.write(schema$1, _input);
|
|
payload = serializer.flush();
|
|
}
|
|
}
|
|
request.headers = headers;
|
|
request.query = query;
|
|
request.body = payload;
|
|
request.method = "POST";
|
|
return request;
|
|
}
|
|
async deserializeResponse(operationSchema, context, response) {
|
|
const deserializer = this.deserializer;
|
|
const ns = schema.NormalizedSchema.of(operationSchema.output);
|
|
const dataObject = {};
|
|
if (response.statusCode >= 300) {
|
|
const bytes = await collectBody(response.body, context);
|
|
if (bytes.byteLength > 0) {
|
|
Object.assign(dataObject, await deserializer.read(15, bytes));
|
|
}
|
|
await this.handleError(operationSchema, context, response, dataObject, this.deserializeMetadata(response));
|
|
throw new Error("@smithy/core/protocols - RPC Protocol error handler failed to throw.");
|
|
}
|
|
for (const header in response.headers) {
|
|
const value = response.headers[header];
|
|
delete response.headers[header];
|
|
response.headers[header.toLowerCase()] = value;
|
|
}
|
|
const eventStreamMember = ns.getEventStreamMember();
|
|
if (eventStreamMember) {
|
|
dataObject[eventStreamMember] = await this.deserializeEventStream({
|
|
response,
|
|
responseSchema: ns,
|
|
initialResponseContainer: dataObject,
|
|
});
|
|
}
|
|
else {
|
|
const bytes = await collectBody(response.body, context);
|
|
if (bytes.byteLength > 0) {
|
|
Object.assign(dataObject, await deserializer.read(ns, bytes));
|
|
}
|
|
}
|
|
dataObject.$metadata = this.deserializeMetadata(response);
|
|
return dataObject;
|
|
}
|
|
}
|
|
|
|
const resolvedPath = (resolvedPath, input, memberName, labelValueProvider, uriLabel, isGreedyLabel) => {
|
|
if (input != null && input[memberName] !== undefined) {
|
|
const labelValue = labelValueProvider();
|
|
if (labelValue.length <= 0) {
|
|
throw new Error("Empty value provided for input HTTP label: " + memberName + ".");
|
|
}
|
|
resolvedPath = resolvedPath.replace(uriLabel, isGreedyLabel
|
|
? labelValue
|
|
.split("/")
|
|
.map((segment) => extendedEncodeURIComponent(segment))
|
|
.join("/")
|
|
: extendedEncodeURIComponent(labelValue));
|
|
}
|
|
else {
|
|
throw new Error("No value provided for input HTTP label: " + memberName + ".");
|
|
}
|
|
return resolvedPath;
|
|
};
|
|
|
|
function requestBuilder(input, context) {
|
|
return new RequestBuilder(input, context);
|
|
}
|
|
class RequestBuilder {
|
|
input;
|
|
context;
|
|
query = {};
|
|
method = "";
|
|
headers = {};
|
|
path = "";
|
|
body = null;
|
|
hostname = "";
|
|
resolvePathStack = [];
|
|
constructor(input, context) {
|
|
this.input = input;
|
|
this.context = context;
|
|
}
|
|
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 protocolHttp.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?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + uriLabel;
|
|
});
|
|
return this;
|
|
}
|
|
p(memberName, labelValueProvider, uriLabel, isGreedyLabel) {
|
|
this.resolvePathStack.push((path) => {
|
|
this.path = 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;
|
|
}
|
|
}
|
|
|
|
function determineTimestampFormat(ns, settings) {
|
|
if (settings.timestampFormat.useTrait) {
|
|
if (ns.isTimestampSchema() &&
|
|
(ns.getSchema() === 5 ||
|
|
ns.getSchema() === 6 ||
|
|
ns.getSchema() === 7)) {
|
|
return ns.getSchema();
|
|
}
|
|
}
|
|
const { httpLabel, httpPrefixHeaders, httpHeader, httpQuery } = ns.getMergedTraits();
|
|
const bindingFormat = settings.httpBindings
|
|
? typeof httpPrefixHeaders === "string" || Boolean(httpHeader)
|
|
? 6
|
|
: Boolean(httpQuery) || Boolean(httpLabel)
|
|
? 5
|
|
: undefined
|
|
: undefined;
|
|
return bindingFormat ?? settings.timestampFormat.default;
|
|
}
|
|
|
|
class FromStringShapeDeserializer extends SerdeContext {
|
|
settings;
|
|
constructor(settings) {
|
|
super();
|
|
this.settings = settings;
|
|
}
|
|
read(_schema, data) {
|
|
const ns = schema.NormalizedSchema.of(_schema);
|
|
if (ns.isListSchema()) {
|
|
return serde.splitHeader(data).map((item) => this.read(ns.getValueSchema(), item));
|
|
}
|
|
if (ns.isBlobSchema()) {
|
|
return (this.serdeContext?.base64Decoder ?? utilBase64.fromBase64)(data);
|
|
}
|
|
if (ns.isTimestampSchema()) {
|
|
const format = determineTimestampFormat(ns, this.settings);
|
|
switch (format) {
|
|
case 5:
|
|
return serde._parseRfc3339DateTimeWithOffset(data);
|
|
case 6:
|
|
return serde._parseRfc7231DateTime(data);
|
|
case 7:
|
|
return serde._parseEpochTimestamp(data);
|
|
default:
|
|
console.warn("Missing timestamp format, parsing value with Date constructor:", data);
|
|
return new Date(data);
|
|
}
|
|
}
|
|
if (ns.isStringSchema()) {
|
|
const mediaType = ns.getMergedTraits().mediaType;
|
|
let intermediateValue = data;
|
|
if (mediaType) {
|
|
if (ns.getMergedTraits().httpHeader) {
|
|
intermediateValue = this.base64ToUtf8(intermediateValue);
|
|
}
|
|
const isJson = mediaType === "application/json" || mediaType.endsWith("+json");
|
|
if (isJson) {
|
|
intermediateValue = serde.LazyJsonString.from(intermediateValue);
|
|
}
|
|
return intermediateValue;
|
|
}
|
|
}
|
|
if (ns.isNumericSchema()) {
|
|
return Number(data);
|
|
}
|
|
if (ns.isBigIntegerSchema()) {
|
|
return BigInt(data);
|
|
}
|
|
if (ns.isBigDecimalSchema()) {
|
|
return new serde.NumericValue(data, "bigDecimal");
|
|
}
|
|
if (ns.isBooleanSchema()) {
|
|
return String(data).toLowerCase() === "true";
|
|
}
|
|
return data;
|
|
}
|
|
base64ToUtf8(base64String) {
|
|
return (this.serdeContext?.utf8Encoder ?? utilUtf8.toUtf8)((this.serdeContext?.base64Decoder ?? utilBase64.fromBase64)(base64String));
|
|
}
|
|
}
|
|
|
|
class HttpInterceptingShapeDeserializer extends SerdeContext {
|
|
codecDeserializer;
|
|
stringDeserializer;
|
|
constructor(codecDeserializer, codecSettings) {
|
|
super();
|
|
this.codecDeserializer = codecDeserializer;
|
|
this.stringDeserializer = new FromStringShapeDeserializer(codecSettings);
|
|
}
|
|
setSerdeContext(serdeContext) {
|
|
this.stringDeserializer.setSerdeContext(serdeContext);
|
|
this.codecDeserializer.setSerdeContext(serdeContext);
|
|
this.serdeContext = serdeContext;
|
|
}
|
|
read(schema$1, data) {
|
|
const ns = schema.NormalizedSchema.of(schema$1);
|
|
const traits = ns.getMergedTraits();
|
|
const toString = this.serdeContext?.utf8Encoder ?? utilUtf8.toUtf8;
|
|
if (traits.httpHeader || traits.httpResponseCode) {
|
|
return this.stringDeserializer.read(ns, toString(data));
|
|
}
|
|
if (traits.httpPayload) {
|
|
if (ns.isBlobSchema()) {
|
|
const toBytes = this.serdeContext?.utf8Decoder ?? utilUtf8.fromUtf8;
|
|
if (typeof data === "string") {
|
|
return toBytes(data);
|
|
}
|
|
return data;
|
|
}
|
|
else if (ns.isStringSchema()) {
|
|
if ("byteLength" in data) {
|
|
return toString(data);
|
|
}
|
|
return data;
|
|
}
|
|
}
|
|
return this.codecDeserializer.read(ns, data);
|
|
}
|
|
}
|
|
|
|
class ToStringShapeSerializer extends SerdeContext {
|
|
settings;
|
|
stringBuffer = "";
|
|
constructor(settings) {
|
|
super();
|
|
this.settings = settings;
|
|
}
|
|
write(schema$1, value) {
|
|
const ns = schema.NormalizedSchema.of(schema$1);
|
|
switch (typeof value) {
|
|
case "object":
|
|
if (value === null) {
|
|
this.stringBuffer = "null";
|
|
return;
|
|
}
|
|
if (ns.isTimestampSchema()) {
|
|
if (!(value instanceof Date)) {
|
|
throw new Error(`@smithy/core/protocols - received non-Date value ${value} when schema expected Date in ${ns.getName(true)}`);
|
|
}
|
|
const format = determineTimestampFormat(ns, this.settings);
|
|
switch (format) {
|
|
case 5:
|
|
this.stringBuffer = value.toISOString().replace(".000Z", "Z");
|
|
break;
|
|
case 6:
|
|
this.stringBuffer = serde.dateToUtcString(value);
|
|
break;
|
|
case 7:
|
|
this.stringBuffer = String(value.getTime() / 1000);
|
|
break;
|
|
default:
|
|
console.warn("Missing timestamp format, using epoch seconds", value);
|
|
this.stringBuffer = String(value.getTime() / 1000);
|
|
}
|
|
return;
|
|
}
|
|
if (ns.isBlobSchema() && "byteLength" in value) {
|
|
this.stringBuffer = (this.serdeContext?.base64Encoder ?? utilBase64.toBase64)(value);
|
|
return;
|
|
}
|
|
if (ns.isListSchema() && Array.isArray(value)) {
|
|
let buffer = "";
|
|
for (const item of value) {
|
|
this.write([ns.getValueSchema(), ns.getMergedTraits()], item);
|
|
const headerItem = this.flush();
|
|
const serialized = ns.getValueSchema().isTimestampSchema() ? headerItem : serde.quoteHeader(headerItem);
|
|
if (buffer !== "") {
|
|
buffer += ", ";
|
|
}
|
|
buffer += serialized;
|
|
}
|
|
this.stringBuffer = buffer;
|
|
return;
|
|
}
|
|
this.stringBuffer = JSON.stringify(value, null, 2);
|
|
break;
|
|
case "string":
|
|
const mediaType = ns.getMergedTraits().mediaType;
|
|
let intermediateValue = value;
|
|
if (mediaType) {
|
|
const isJson = mediaType === "application/json" || mediaType.endsWith("+json");
|
|
if (isJson) {
|
|
intermediateValue = serde.LazyJsonString.from(intermediateValue);
|
|
}
|
|
if (ns.getMergedTraits().httpHeader) {
|
|
this.stringBuffer = (this.serdeContext?.base64Encoder ?? utilBase64.toBase64)(intermediateValue.toString());
|
|
return;
|
|
}
|
|
}
|
|
this.stringBuffer = value;
|
|
break;
|
|
default:
|
|
if (ns.isIdempotencyToken()) {
|
|
this.stringBuffer = serde.generateIdempotencyToken();
|
|
}
|
|
else {
|
|
this.stringBuffer = String(value);
|
|
}
|
|
}
|
|
}
|
|
flush() {
|
|
const buffer = this.stringBuffer;
|
|
this.stringBuffer = "";
|
|
return buffer;
|
|
}
|
|
}
|
|
|
|
class HttpInterceptingShapeSerializer {
|
|
codecSerializer;
|
|
stringSerializer;
|
|
buffer;
|
|
constructor(codecSerializer, codecSettings, stringSerializer = new ToStringShapeSerializer(codecSettings)) {
|
|
this.codecSerializer = codecSerializer;
|
|
this.stringSerializer = stringSerializer;
|
|
}
|
|
setSerdeContext(serdeContext) {
|
|
this.codecSerializer.setSerdeContext(serdeContext);
|
|
this.stringSerializer.setSerdeContext(serdeContext);
|
|
}
|
|
write(schema$1, value) {
|
|
const ns = schema.NormalizedSchema.of(schema$1);
|
|
const traits = ns.getMergedTraits();
|
|
if (traits.httpHeader || traits.httpLabel || traits.httpQuery) {
|
|
this.stringSerializer.write(ns, value);
|
|
this.buffer = this.stringSerializer.flush();
|
|
return;
|
|
}
|
|
return this.codecSerializer.write(ns, value);
|
|
}
|
|
flush() {
|
|
if (this.buffer !== undefined) {
|
|
const buffer = this.buffer;
|
|
this.buffer = undefined;
|
|
return buffer;
|
|
}
|
|
return this.codecSerializer.flush();
|
|
}
|
|
}
|
|
|
|
exports.FromStringShapeDeserializer = FromStringShapeDeserializer;
|
|
exports.HttpBindingProtocol = HttpBindingProtocol;
|
|
exports.HttpInterceptingShapeDeserializer = HttpInterceptingShapeDeserializer;
|
|
exports.HttpInterceptingShapeSerializer = HttpInterceptingShapeSerializer;
|
|
exports.HttpProtocol = HttpProtocol;
|
|
exports.RequestBuilder = RequestBuilder;
|
|
exports.RpcProtocol = RpcProtocol;
|
|
exports.SerdeContext = SerdeContext;
|
|
exports.ToStringShapeSerializer = ToStringShapeSerializer;
|
|
exports.collectBody = collectBody;
|
|
exports.determineTimestampFormat = determineTimestampFormat;
|
|
exports.extendedEncodeURIComponent = extendedEncodeURIComponent;
|
|
exports.requestBuilder = requestBuilder;
|
|
exports.resolvedPath = resolvedPath;
|