@gemeentenijmegen/webapp 1.1.8 → 1.1.9

package/node_modules/@aws-sdk/core/dist-es/submodules/httpAuthSchemes/index.js

@@ -1 +1,2 @@
 export * from "./aws_sdk";
+export * from "./utils/getBearerTokenEnvKey";

package/node_modules/@aws-sdk/core/dist-es/submodules/protocols/ConfigurableSerdeContext.js

@@ -0,0 +1,6 @@
+export class SerdeContextConfig {
+    serdeContext;
+    setSerdeContext(serdeContext) {
+        this.serdeContext = serdeContext;
+    }
+}

package/node_modules/@aws-sdk/core/dist-es/submodules/protocols/index.js

@@ -1,4 +1,17 @@
 export * from "./coercing-serializers";
+export * from "./json/AwsJson1_0Protocol";
+export * from "./json/AwsJson1_1Protocol";
+export * from "./json/AwsJsonRpcProtocol";
+export * from "./json/AwsRestJsonProtocol";
+export * from "./json/JsonCodec";
+export * from "./json/JsonShapeDeserializer";
+export * from "./json/JsonShapeSerializer";
 export * from "./json/awsExpectUnion";
 export * from "./json/parseJsonBody";
+export * from "./query/AwsEc2QueryProtocol";
+export * from "./query/AwsQueryProtocol";
+export * from "./xml/AwsRestXmlProtocol";
+export * from "./xml/XmlCodec";
+export * from "./xml/XmlShapeDeserializer";
+export * from "./xml/XmlShapeSerializer";
 export * from "./xml/parseXmlBody";

package/node_modules/@aws-sdk/core/dist-es/submodules/protocols/json/AwsJson1_0Protocol.js

@@ -0,0 +1,14 @@
+import { AwsJsonRpcProtocol } from "./AwsJsonRpcProtocol";
+export class AwsJson1_0Protocol extends AwsJsonRpcProtocol {
+    constructor({ defaultNamespace }) {
+        super({
+            defaultNamespace,
+        });
+    }
+    getShapeId() {
+        return "aws.protocols#awsJson1_0";
+    }
+    getJsonRpcVersion() {
+        return "1.0";
+    }
+}

package/node_modules/@aws-sdk/core/dist-es/submodules/protocols/json/AwsJson1_1Protocol.js

@@ -0,0 +1,14 @@
+import { AwsJsonRpcProtocol } from "./AwsJsonRpcProtocol";
+export class AwsJson1_1Protocol extends AwsJsonRpcProtocol {
+    constructor({ defaultNamespace }) {
+        super({
+            defaultNamespace,
+        });
+    }
+    getShapeId() {
+        return "aws.protocols#awsJson1_1";
+    }
+    getJsonRpcVersion() {
+        return "1.1";
+    }
+}

package/node_modules/@aws-sdk/core/dist-es/submodules/protocols/json/AwsJsonRpcProtocol.js

@@ -0,0 +1,84 @@
+import { RpcProtocol } from "@smithy/core/protocols";
+import { deref, NormalizedSchema, SCHEMA, TypeRegistry } from "@smithy/core/schema";
+import { calculateBodyLength } from "@smithy/util-body-length-browser";
+import { JsonCodec } from "./JsonCodec";
+import { loadRestJsonErrorCode } from "./parseJsonBody";
+export class AwsJsonRpcProtocol extends RpcProtocol {
+    serializer;
+    deserializer;
+    codec;
+    constructor({ defaultNamespace }) {
+        super({
+            defaultNamespace,
+        });
+        this.codec = new JsonCodec({
+            timestampFormat: {
+                useTrait: true,
+                default: SCHEMA.TIMESTAMP_EPOCH_SECONDS,
+            },
+            jsonName: false,
+        });
+        this.serializer = this.codec.createSerializer();
+        this.deserializer = this.codec.createDeserializer();
+    }
+    async serializeRequest(operationSchema, input, context) {
+        const request = await super.serializeRequest(operationSchema, input, context);
+        if (!request.path.endsWith("/")) {
+            request.path += "/";
+        }
+        Object.assign(request.headers, {
+            "content-type": `application/x-amz-json-${this.getJsonRpcVersion()}`,
+            "x-amz-target": (this.getJsonRpcVersion() === "1.0" ? `JsonRpc10.` : `JsonProtocol.`) +
+                NormalizedSchema.of(operationSchema).getName(),
+        });
+        if (deref(operationSchema.input) === "unit" || !request.body) {
+            request.body = "{}";
+        }
+        try {
+            request.headers["content-length"] = String(calculateBodyLength(request.body));
+        }
+        catch (e) { }
+        return request;
+    }
+    getPayloadCodec() {
+        return this.codec;
+    }
+    async handleError(operationSchema, context, response, dataObject, metadata) {
+        const errorIdentifier = loadRestJsonErrorCode(response, dataObject) ?? "Unknown";
+        let namespace = this.options.defaultNamespace;
+        let errorName = errorIdentifier;
+        if (errorIdentifier.includes("#")) {
+            [namespace, errorName] = errorIdentifier.split("#");
+        }
+        const registry = TypeRegistry.for(namespace);
+        let errorSchema;
+        try {
+            errorSchema = registry.getSchema(errorIdentifier);
+        }
+        catch (e) {
+            const baseExceptionSchema = TypeRegistry.for("smithy.ts.sdk.synthetic." + namespace).getBaseException();
+            if (baseExceptionSchema) {
+                const ErrorCtor = baseExceptionSchema.ctor;
+                throw Object.assign(new ErrorCtor(errorName), dataObject);
+            }
+            throw new Error(errorName);
+        }
+        const ns = NormalizedSchema.of(errorSchema);
+        const message = dataObject.message ?? dataObject.Message ?? "Unknown";
+        const exception = new errorSchema.ctor(message);
+        await this.deserializeHttpMessage(errorSchema, context, response, dataObject);
+        const output = {};
+        for (const [name, member] of ns.structIterator()) {
+            const target = member.getMergedTraits().jsonName ?? name;
+            output[name] = this.codec.createDeserializer().readObject(member, dataObject[target]);
+        }
+        Object.assign(exception, {
+            $metadata: metadata,
+            $response: response,
+            $fault: ns.getMergedTraits().error,
+            message,
+            ...output,
+        });
+        throw exception;
+    }
+}

package/node_modules/@aws-sdk/core/dist-es/submodules/protocols/json/AwsRestJsonProtocol.js

@@ -0,0 +1,118 @@
+import { HttpBindingProtocol, HttpInterceptingShapeDeserializer, HttpInterceptingShapeSerializer, } from "@smithy/core/protocols";
+import { NormalizedSchema, SCHEMA, TypeRegistry } from "@smithy/core/schema";
+import { calculateBodyLength } from "@smithy/util-body-length-browser";
+import { JsonCodec } from "./JsonCodec";
+import { loadRestJsonErrorCode } from "./parseJsonBody";
+export class AwsRestJsonProtocol extends HttpBindingProtocol {
+    serializer;
+    deserializer;
+    codec;
+    constructor({ defaultNamespace }) {
+        super({
+            defaultNamespace,
+        });
+        const settings = {
+            timestampFormat: {
+                useTrait: true,
+                default: SCHEMA.TIMESTAMP_EPOCH_SECONDS,
+            },
+            httpBindings: true,
+            jsonName: true,
+        };
+        this.codec = new JsonCodec(settings);
+        this.serializer = new HttpInterceptingShapeSerializer(this.codec.createSerializer(), settings);
+        this.deserializer = new HttpInterceptingShapeDeserializer(this.codec.createDeserializer(), settings);
+    }
+    getShapeId() {
+        return "aws.protocols#restJson1";
+    }
+    getPayloadCodec() {
+        return this.codec;
+    }
+    setSerdeContext(serdeContext) {
+        this.codec.setSerdeContext(serdeContext);
+        super.setSerdeContext(serdeContext);
+    }
+    async serializeRequest(operationSchema, input, context) {
+        const request = await super.serializeRequest(operationSchema, input, context);
+        const inputSchema = NormalizedSchema.of(operationSchema.input);
+        const members = inputSchema.getMemberSchemas();
+        if (!request.headers["content-type"]) {
+            const httpPayloadMember = Object.values(members).find((m) => {
+                return !!m.getMergedTraits().httpPayload;
+            });
+            if (httpPayloadMember) {
+                const mediaType = httpPayloadMember.getMergedTraits().mediaType;
+                if (mediaType) {
+                    request.headers["content-type"] = mediaType;
+                }
+                else if (httpPayloadMember.isStringSchema()) {
+                    request.headers["content-type"] = "text/plain";
+                }
+                else if (httpPayloadMember.isBlobSchema()) {
+                    request.headers["content-type"] = "application/octet-stream";
+                }
+                else {
+                    request.headers["content-type"] = "application/json";
+                }
+            }
+            else if (!inputSchema.isUnitSchema()) {
+                const hasBody = Object.values(members).find((m) => {
+                    const { httpQuery, httpQueryParams, httpHeader, httpLabel, httpPrefixHeaders } = m.getMergedTraits();
+                    return !httpQuery && !httpQueryParams && !httpHeader && !httpLabel && httpPrefixHeaders === void 0;
+                });
+                if (hasBody) {
+                    request.headers["content-type"] = "application/json";
+                }
+            }
+        }
+        if (request.headers["content-type"] && !request.body) {
+            request.body = "{}";
+        }
+        if (request.body) {
+            try {
+                request.headers["content-length"] = String(calculateBodyLength(request.body));
+            }
+            catch (e) { }
+        }
+        return request;
+    }
+    async handleError(operationSchema, context, response, dataObject, metadata) {
+        const errorIdentifier = loadRestJsonErrorCode(response, dataObject) ?? "Unknown";
+        let namespace = this.options.defaultNamespace;
+        let errorName = errorIdentifier;
+        if (errorIdentifier.includes("#")) {
+            [namespace, errorName] = errorIdentifier.split("#");
+        }
+        const registry = TypeRegistry.for(namespace);
+        let errorSchema;
+        try {
+            errorSchema = registry.getSchema(errorIdentifier);
+        }
+        catch (e) {
+            const baseExceptionSchema = TypeRegistry.for("smithy.ts.sdk.synthetic." + namespace).getBaseException();
+            if (baseExceptionSchema) {
+                const ErrorCtor = baseExceptionSchema.ctor;
+                throw Object.assign(new ErrorCtor(errorName), dataObject);
+            }
+            throw new Error(errorName);
+        }
+        const ns = NormalizedSchema.of(errorSchema);
+        const message = dataObject.message ?? dataObject.Message ?? "Unknown";
+        const exception = new errorSchema.ctor(message);
+        await this.deserializeHttpMessage(errorSchema, context, response, dataObject);
+        const output = {};
+        for (const [name, member] of ns.structIterator()) {
+            const target = member.getMergedTraits().jsonName ?? name;
+            output[name] = this.codec.createDeserializer().readObject(member, dataObject[target]);
+        }
+        Object.assign(exception, {
+            $metadata: metadata,
+            $response: response,
+            $fault: ns.getMergedTraits().error,
+            message,
+            ...output,
+        });
+        throw exception;
+    }
+}

package/node_modules/@aws-sdk/core/dist-es/submodules/protocols/json/JsonCodec.js

@@ -0,0 +1,20 @@
+import { SerdeContextConfig } from "../ConfigurableSerdeContext";
+import { JsonShapeDeserializer } from "./JsonShapeDeserializer";
+import { JsonShapeSerializer } from "./JsonShapeSerializer";
+export class JsonCodec extends SerdeContextConfig {
+    settings;
+    constructor(settings) {
+        super();
+        this.settings = settings;
+    }
+    createSerializer() {
+        const serializer = new JsonShapeSerializer(this.settings);
+        serializer.setSerdeContext(this.serdeContext);
+        return serializer;
+    }
+    createDeserializer() {
+        const deserializer = new JsonShapeDeserializer(this.settings);
+        deserializer.setSerdeContext(this.serdeContext);
+        return deserializer;
+    }
+}

package/node_modules/@aws-sdk/core/dist-es/submodules/protocols/json/JsonShapeDeserializer.js

@@ -0,0 +1,105 @@
+import { NormalizedSchema, SCHEMA } from "@smithy/core/schema";
+import { LazyJsonString, NumericValue, parseEpochTimestamp, parseRfc3339DateTimeWithOffset, parseRfc7231DateTime, } from "@smithy/core/serde";
+import { fromBase64 } from "@smithy/util-base64";
+import { SerdeContextConfig } from "../ConfigurableSerdeContext";
+import { jsonReviver } from "./jsonReviver";
+import { parseJsonBody } from "./parseJsonBody";
+export class JsonShapeDeserializer extends SerdeContextConfig {
+    settings;
+    constructor(settings) {
+        super();
+        this.settings = settings;
+    }
+    async read(schema, data) {
+        return this._read(schema, typeof data === "string" ? JSON.parse(data, jsonReviver) : await parseJsonBody(data, this.serdeContext));
+    }
+    readObject(schema, data) {
+        return this._read(schema, data);
+    }
+    _read(schema, value) {
+        const isObject = value !== null && typeof value === "object";
+        const ns = NormalizedSchema.of(schema);
+        if (ns.isListSchema() && Array.isArray(value)) {
+            const listMember = ns.getValueSchema();
+            const out = [];
+            const sparse = !!ns.getMergedTraits().sparse;
+            for (const item of value) {
+                if (sparse || item != null) {
+                    out.push(this._read(listMember, item));
+                }
+            }
+            return out;
+        }
+        else if (ns.isMapSchema() && isObject) {
+            const mapMember = ns.getValueSchema();
+            const out = {};
+            const sparse = !!ns.getMergedTraits().sparse;
+            for (const [_k, _v] of Object.entries(value)) {
+                if (sparse || _v != null) {
+                    out[_k] = this._read(mapMember, _v);
+                }
+            }
+            return out;
+        }
+        else if (ns.isStructSchema() && isObject) {
+            const out = {};
+            for (const [memberName, memberSchema] of ns.structIterator()) {
+                const fromKey = this.settings.jsonName ? memberSchema.getMergedTraits().jsonName ?? memberName : memberName;
+                const deserializedValue = this._read(memberSchema, value[fromKey]);
+                if (deserializedValue != null) {
+                    out[memberName] = deserializedValue;
+                }
+            }
+            return out;
+        }
+        if (ns.isBlobSchema() && typeof value === "string") {
+            return fromBase64(value);
+        }
+        const mediaType = ns.getMergedTraits().mediaType;
+        if (ns.isStringSchema() && typeof value === "string" && mediaType) {
+            const isJson = mediaType === "application/json" || mediaType.endsWith("+json");
+            if (isJson) {
+                return LazyJsonString.from(value);
+            }
+        }
+        if (ns.isTimestampSchema()) {
+            const options = this.settings.timestampFormat;
+            const format = options.useTrait
+                ? ns.getSchema() === SCHEMA.TIMESTAMP_DEFAULT
+                    ? options.default
+                    : ns.getSchema() ?? options.default
+                : options.default;
+            switch (format) {
+                case SCHEMA.TIMESTAMP_DATE_TIME:
+                    return parseRfc3339DateTimeWithOffset(value);
+                case SCHEMA.TIMESTAMP_HTTP_DATE:
+                    return parseRfc7231DateTime(value);
+                case SCHEMA.TIMESTAMP_EPOCH_SECONDS:
+                    return parseEpochTimestamp(value);
+                default:
+                    console.warn("Missing timestamp format, parsing value with Date constructor:", value);
+                    return new Date(value);
+            }
+        }
+        if (ns.isBigIntegerSchema() && (typeof value === "number" || typeof value === "string")) {
+            return BigInt(value);
+        }
+        if (ns.isBigDecimalSchema() && value != undefined) {
+            if (value instanceof NumericValue) {
+                return value;
+            }
+            return new NumericValue(String(value), "bigDecimal");
+        }
+        if (ns.isNumericSchema() && typeof value === "string") {
+            switch (value) {
+                case "Infinity":
+                    return Infinity;
+                case "-Infinity":
+                    return -Infinity;
+                case "NaN":
+                    return NaN;
+            }
+        }
+        return value;
+    }
+}

package/node_modules/@aws-sdk/core/dist-es/submodules/protocols/json/JsonShapeSerializer.js

@@ -0,0 +1,106 @@
+import { NormalizedSchema, SCHEMA } from "@smithy/core/schema";
+import { dateToUtcString } from "@smithy/core/serde";
+import { LazyJsonString } from "@smithy/core/serde";
+import { SerdeContextConfig } from "../ConfigurableSerdeContext";
+import { JsonReplacer } from "./jsonReplacer";
+export class JsonShapeSerializer extends SerdeContextConfig {
+    settings;
+    buffer;
+    rootSchema;
+    constructor(settings) {
+        super();
+        this.settings = settings;
+    }
+    write(schema, value) {
+        this.rootSchema = NormalizedSchema.of(schema);
+        this.buffer = this._write(this.rootSchema, value);
+    }
+    flush() {
+        if (this.rootSchema?.isStructSchema() || this.rootSchema?.isDocumentSchema()) {
+            const replacer = new JsonReplacer();
+            return replacer.replaceInJson(JSON.stringify(this.buffer, replacer.createReplacer(), 0));
+        }
+        return this.buffer;
+    }
+    _write(schema, value, container) {
+        const isObject = value !== null && typeof value === "object";
+        const ns = NormalizedSchema.of(schema);
+        if (ns.isListSchema() && Array.isArray(value)) {
+            const listMember = ns.getValueSchema();
+            const out = [];
+            const sparse = !!ns.getMergedTraits().sparse;
+            for (const item of value) {
+                if (sparse || item != null) {
+                    out.push(this._write(listMember, item));
+                }
+            }
+            return out;
+        }
+        else if (ns.isMapSchema() && isObject) {
+            const mapMember = ns.getValueSchema();
+            const out = {};
+            const sparse = !!ns.getMergedTraits().sparse;
+            for (const [_k, _v] of Object.entries(value)) {
+                if (sparse || _v != null) {
+                    out[_k] = this._write(mapMember, _v);
+                }
+            }
+            return out;
+        }
+        else if (ns.isStructSchema() && isObject) {
+            const out = {};
+            for (const [memberName, memberSchema] of ns.structIterator()) {
+                const targetKey = this.settings.jsonName ? memberSchema.getMergedTraits().jsonName ?? memberName : memberName;
+                const serializableValue = this._write(memberSchema, value[memberName], ns);
+                if (serializableValue !== undefined) {
+                    out[targetKey] = serializableValue;
+                }
+            }
+            return out;
+        }
+        if (value === null && container?.isStructSchema()) {
+            return void 0;
+        }
+        if (ns.isBlobSchema() && (value instanceof Uint8Array || typeof value === "string")) {
+            if (ns === this.rootSchema) {
+                return value;
+            }
+            if (!this.serdeContext?.base64Encoder) {
+                throw new Error("Missing base64Encoder in serdeContext");
+            }
+            return this.serdeContext?.base64Encoder(value);
+        }
+        if (ns.isTimestampSchema() && value instanceof Date) {
+            const options = this.settings.timestampFormat;
+            const format = options.useTrait
+                ? ns.getSchema() === SCHEMA.TIMESTAMP_DEFAULT
+                    ? options.default
+                    : ns.getSchema() ?? options.default
+                : options.default;
+            switch (format) {
+                case SCHEMA.TIMESTAMP_DATE_TIME:
+                    return value.toISOString().replace(".000Z", "Z");
+                case SCHEMA.TIMESTAMP_HTTP_DATE:
+                    return dateToUtcString(value);
+                case SCHEMA.TIMESTAMP_EPOCH_SECONDS:
+                    return value.getTime() / 1000;
+                default:
+                    console.warn("Missing timestamp format, using epoch seconds", value);
+                    return value.getTime() / 1000;
+            }
+        }
+        if (ns.isNumericSchema() && typeof value === "number") {
+            if (Math.abs(value) === Infinity || isNaN(value)) {
+                return String(value);
+            }
+        }
+        const mediaType = ns.getMergedTraits().mediaType;
+        if (ns.isStringSchema() && typeof value === "string" && mediaType) {
+            const isJson = mediaType === "application/json" || mediaType.endsWith("+json");
+            if (isJson) {
+                return LazyJsonString.from(value);
+            }
+        }
+        return value;
+    }
+}

package/node_modules/@aws-sdk/core/dist-es/submodules/protocols/json/jsonReplacer.js

@@ -0,0 +1,46 @@
+import { NumericValue } from "@smithy/core/serde";
+const NUMERIC_CONTROL_CHAR = String.fromCharCode(925);
+export class JsonReplacer {
+    values = new Map();
+    counter = 0;
+    stage = 0;
+    createReplacer() {
+        if (this.stage === 1) {
+            throw new Error("@aws-sdk/core/protocols - JsonReplacer already created.");
+        }
+        if (this.stage === 2) {
+            throw new Error("@aws-sdk/core/protocols - JsonReplacer exhausted.");
+        }
+        this.stage = 1;
+        return (key, value) => {
+            if (value instanceof NumericValue) {
+                const v = `${NUMERIC_CONTROL_CHAR + +"nv" + this.counter++}_` + value.string;
+                this.values.set(`"${v}"`, value.string);
+                return v;
+            }
+            if (typeof value === "bigint") {
+                const s = value.toString();
+                const v = `${NUMERIC_CONTROL_CHAR + "b" + this.counter++}_` + s;
+                this.values.set(`"${v}"`, s);
+                return v;
+            }
+            return value;
+        };
+    }
+    replaceInJson(json) {
+        if (this.stage === 0) {
+            throw new Error("@aws-sdk/core/protocols - JsonReplacer not created yet.");
+        }
+        if (this.stage === 2) {
+            throw new Error("@aws-sdk/core/protocols - JsonReplacer exhausted.");
+        }
+        this.stage = 2;
+        if (this.counter === 0) {
+            return json;
+        }
+        for (const [key, value] of this.values) {
+            json = json.replace(key, value);
+        }
+        return json;
+    }
+}

package/node_modules/@aws-sdk/core/dist-es/submodules/protocols/json/jsonReviver.js

@@ -0,0 +1,18 @@
+import { NumericValue } from "@smithy/core/serde";
+export function jsonReviver(key, value, context) {
+    if (context?.source) {
+        const numericString = context.source;
+        if (typeof value === "number") {
+            if (value > Number.MAX_SAFE_INTEGER || value < Number.MIN_SAFE_INTEGER || numericString !== String(value)) {
+                const isFractional = numericString.includes(".");
+                if (isFractional) {
+                    return new NumericValue(numericString, "bigDecimal");
+                }
+                else {
+                    return BigInt(numericString);
+                }
+            }
+        }
+    }
+    return value;
+}

package/node_modules/@aws-sdk/core/dist-es/submodules/protocols/query/AwsEc2QueryProtocol.js

@@ -0,0 +1,17 @@
+import { AwsQueryProtocol } from "./AwsQueryProtocol";
+export class AwsEc2QueryProtocol extends AwsQueryProtocol {
+    options;
+    constructor(options) {
+        super(options);
+        this.options = options;
+        const ec2Settings = {
+            capitalizeKeys: true,
+            flattenLists: true,
+            serializeEmptyLists: false,
+        };
+        Object.assign(this.serializer.settings, ec2Settings);
+    }
+    useNestedResult() {
+        return false;
+    }
+}