@hot-updater/aws 0.26.0 → 0.26.2

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import { S3ClientConfig } from "@aws-sdk/client-s3";
-import * as _hot_updater_plugin_core1 from "@hot-updater/plugin-core";
+import * as _hot_updater_plugin_core0 from "@hot-updater/plugin-core";
 
 //#region src/s3Database.d.ts
 interface S3DatabaseConfig extends S3ClientConfig {
@@ -14,7 +14,7 @@ interface S3DatabaseConfig extends S3ClientConfig {
   cloudfrontDistributionId?: string;
   apiBasePath?: string;
 }
-declare const s3Database: (config: S3DatabaseConfig, hooks?: _hot_updater_plugin_core1.DatabasePluginHooks) => () => _hot_updater_plugin_core1.DatabasePlugin;
+declare const s3Database: (config: S3DatabaseConfig, hooks?: _hot_updater_plugin_core0.DatabasePluginHooks) => () => _hot_updater_plugin_core0.DatabasePlugin;
 //#endregion
 //#region src/s3Storage.d.ts
 interface S3StorageConfig extends S3ClientConfig {
@@ -24,6 +24,6 @@ interface S3StorageConfig extends S3ClientConfig {
    */
   basePath?: string;
 }
-declare const s3Storage: (config: S3StorageConfig, hooks?: _hot_updater_plugin_core1.StoragePluginHooks) => () => _hot_updater_plugin_core1.StoragePlugin;
+declare const s3Storage: (config: S3StorageConfig, hooks?: _hot_updater_plugin_core0.StoragePluginHooks) => () => _hot_updater_plugin_core0.StoragePlugin;
 //#endregion
 export { S3DatabaseConfig, S3StorageConfig, s3Database, s3Storage };

package/dist/lambda/dist-cjs-Mm7FDWb8.cjs

@@ -0,0 +1,128 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function() {
+	return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function() {
+	return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (all) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+//#endregion
+
+//#region ../../node_modules/.pnpm/@smithy+is-array-buffer@4.2.2/node_modules/@smithy/is-array-buffer/dist-cjs/index.js
+var require_dist_cjs$2 = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/@smithy+is-array-buffer@4.2.2/node_modules/@smithy/is-array-buffer/dist-cjs/index.js": ((exports) => {
+	const isArrayBuffer$1 = (arg) => typeof ArrayBuffer === "function" && arg instanceof ArrayBuffer || Object.prototype.toString.call(arg) === "[object ArrayBuffer]";
+	exports.isArrayBuffer = isArrayBuffer$1;
+}) });
+
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+util-buffer-from@4.2.2/node_modules/@smithy/util-buffer-from/dist-cjs/index.js
+var require_dist_cjs$1 = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/@smithy+util-buffer-from@4.2.2/node_modules/@smithy/util-buffer-from/dist-cjs/index.js": ((exports) => {
+	var isArrayBuffer = require_dist_cjs$2();
+	var buffer = require("buffer");
+	const fromArrayBuffer = (input, offset = 0, length = input.byteLength - offset) => {
+		if (!isArrayBuffer.isArrayBuffer(input)) throw new TypeError(`The "input" argument must be ArrayBuffer. Received type ${typeof input} (${input})`);
+		return buffer.Buffer.from(input, offset, length);
+	};
+	const fromString = (input, encoding) => {
+		if (typeof input !== "string") throw new TypeError(`The "input" argument must be of type string. Received type ${typeof input} (${input})`);
+		return encoding ? buffer.Buffer.from(input, encoding) : buffer.Buffer.from(input);
+	};
+	exports.fromArrayBuffer = fromArrayBuffer;
+	exports.fromString = fromString;
+}) });
+
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+util-utf8@4.2.2/node_modules/@smithy/util-utf8/dist-cjs/index.js
+var require_dist_cjs = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/@smithy+util-utf8@4.2.2/node_modules/@smithy/util-utf8/dist-cjs/index.js": ((exports) => {
+	var utilBufferFrom = require_dist_cjs$1();
+	const fromUtf8 = (input) => {
+		const buf = utilBufferFrom.fromString(input, "utf8");
+		return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength / Uint8Array.BYTES_PER_ELEMENT);
+	};
+	const toUint8Array = (data) => {
+		if (typeof data === "string") return fromUtf8(data);
+		if (ArrayBuffer.isView(data)) return new Uint8Array(data.buffer, data.byteOffset, data.byteLength / Uint8Array.BYTES_PER_ELEMENT);
+		return new Uint8Array(data);
+	};
+	const toUtf8 = (input) => {
+		if (typeof input === "string") return input;
+		if (typeof input !== "object" || typeof input.byteOffset !== "number" || typeof input.byteLength !== "number") throw new Error("@smithy/util-utf8: toUtf8 encoder function only accepts string | Uint8Array.");
+		return utilBufferFrom.fromArrayBuffer(input.buffer, input.byteOffset, input.byteLength).toString("utf8");
+	};
+	exports.fromUtf8 = fromUtf8;
+	exports.toUint8Array = toUint8Array;
+	exports.toUtf8 = toUtf8;
+}) });
+
+//#endregion
+Object.defineProperty(exports, '__commonJS', {
+  enumerable: true,
+  get: function () {
+    return __commonJS;
+  }
+});
+Object.defineProperty(exports, '__esm', {
+  enumerable: true,
+  get: function () {
+    return __esm;
+  }
+});
+Object.defineProperty(exports, '__export', {
+  enumerable: true,
+  get: function () {
+    return __export;
+  }
+});
+Object.defineProperty(exports, '__toCommonJS', {
+  enumerable: true,
+  get: function () {
+    return __toCommonJS;
+  }
+});
+Object.defineProperty(exports, '__toESM', {
+  enumerable: true,
+  get: function () {
+    return __toESM;
+  }
+});
+Object.defineProperty(exports, 'require_dist_cjs', {
+  enumerable: true,
+  get: function () {
+    return require_dist_cjs;
+  }
+});
+Object.defineProperty(exports, 'require_dist_cjs$1', {
+  enumerable: true,
+  get: function () {
+    return require_dist_cjs$1;
+  }
+});

package/dist/lambda/event-streams-0D7SB645.cjs

@@ -0,0 +1,204 @@
+const require_dist_cjs$1 = require('./dist-cjs-Mm7FDWb8.cjs');
+
+//#region ../../node_modules/.pnpm/@smithy+core@3.23.11/node_modules/@smithy/core/dist-es/submodules/event-streams/EventStreamSerde.js
+var import_dist_cjs, EventStreamSerde;
+var init_EventStreamSerde = require_dist_cjs$1.__esm({ "../../node_modules/.pnpm/@smithy+core@3.23.11/node_modules/@smithy/core/dist-es/submodules/event-streams/EventStreamSerde.js": (() => {
+	import_dist_cjs = /* @__PURE__ */ require_dist_cjs$1.__toESM(require_dist_cjs$1.require_dist_cjs());
+	EventStreamSerde = class {
+		marshaller;
+		serializer;
+		deserializer;
+		serdeContext;
+		defaultContentType;
+		constructor({ marshaller, serializer, deserializer, serdeContext, defaultContentType }) {
+			this.marshaller = marshaller;
+			this.serializer = serializer;
+			this.deserializer = deserializer;
+			this.serdeContext = serdeContext;
+			this.defaultContentType = defaultContentType;
+		}
+		async serializeEventStream({ eventStream, requestSchema, initialRequest }) {
+			const marshaller = this.marshaller;
+			const eventStreamMember = requestSchema.getEventStreamMember();
+			const unionSchema = requestSchema.getMemberSchema(eventStreamMember);
+			const serializer = this.serializer;
+			const defaultContentType = this.defaultContentType;
+			const initialRequestMarker = Symbol("initialRequestMarker");
+			const eventStreamIterable = { async *[Symbol.asyncIterator]() {
+				if (initialRequest) {
+					const headers = {
+						":event-type": {
+							type: "string",
+							value: "initial-request"
+						},
+						":message-type": {
+							type: "string",
+							value: "event"
+						},
+						":content-type": {
+							type: "string",
+							value: defaultContentType
+						}
+					};
+					serializer.write(requestSchema, initialRequest);
+					const body = serializer.flush();
+					yield {
+						[initialRequestMarker]: true,
+						headers,
+						body
+					};
+				}
+				for await (const page of eventStream) yield page;
+			} };
+			return marshaller.serialize(eventStreamIterable, (event) => {
+				if (event[initialRequestMarker]) return {
+					headers: event.headers,
+					body: event.body
+				};
+				const unionMember = Object.keys(event).find((key) => {
+					return key !== "__type";
+				}) ?? "";
+				const { additionalHeaders, body, eventType, explicitPayloadContentType } = this.writeEventBody(unionMember, unionSchema, event);
+				return {
+					headers: {
+						":event-type": {
+							type: "string",
+							value: eventType
+						},
+						":message-type": {
+							type: "string",
+							value: "event"
+						},
+						":content-type": {
+							type: "string",
+							value: explicitPayloadContentType ?? defaultContentType
+						},
+						...additionalHeaders
+					},
+					body
+				};
+			});
+		}
+		async deserializeEventStream({ response, responseSchema, initialResponseContainer }) {
+			const marshaller = this.marshaller;
+			const eventStreamMember = responseSchema.getEventStreamMember();
+			const memberSchemas = responseSchema.getMemberSchema(eventStreamMember).getMemberSchemas();
+			const initialResponseMarker = Symbol("initialResponseMarker");
+			const asyncIterable = marshaller.deserialize(response.body, async (event) => {
+				const unionMember = Object.keys(event).find((key) => {
+					return key !== "__type";
+				}) ?? "";
+				const body = event[unionMember].body;
+				if (unionMember === "initial-response") {
+					const dataObject = await this.deserializer.read(responseSchema, body);
+					delete dataObject[eventStreamMember];
+					return {
+						[initialResponseMarker]: true,
+						...dataObject
+					};
+				} else if (unionMember in memberSchemas) {
+					const eventStreamSchema = memberSchemas[unionMember];
+					if (eventStreamSchema.isStructSchema()) {
+						const out = {};
+						let hasBindings = false;
+						for (const [name, member] of eventStreamSchema.structIterator()) {
+							const { eventHeader, eventPayload } = member.getMergedTraits();
+							hasBindings = hasBindings || Boolean(eventHeader || eventPayload);
+							if (eventPayload) {
+								if (member.isBlobSchema()) out[name] = body;
+								else if (member.isStringSchema()) out[name] = (this.serdeContext?.utf8Encoder ?? import_dist_cjs.toUtf8)(body);
+								else if (member.isStructSchema()) out[name] = await this.deserializer.read(member, body);
+							} else if (eventHeader) {
+								const value = event[unionMember].headers[name]?.value;
+								if (value != null) if (member.isNumericSchema()) if (value && typeof value === "object" && "bytes" in value) out[name] = BigInt(value.toString());
+								else out[name] = Number(value);
+								else out[name] = value;
+							}
+						}
+						if (hasBindings) return { [unionMember]: out };
+						if (body.byteLength === 0) return { [unionMember]: {} };
+					}
+					return { [unionMember]: await this.deserializer.read(eventStreamSchema, body) };
+				} else return { $unknown: event };
+			});
+			const asyncIterator = asyncIterable[Symbol.asyncIterator]();
+			const firstEvent = await asyncIterator.next();
+			if (firstEvent.done) return asyncIterable;
+			if (firstEvent.value?.[initialResponseMarker]) {
+				if (!responseSchema) throw new Error("@smithy::core/protocols - initial-response event encountered in event stream but no response schema given.");
+				for (const [key, value] of Object.entries(firstEvent.value)) initialResponseContainer[key] = value;
+			}
+			return { async *[Symbol.asyncIterator]() {
+				if (!firstEvent?.value?.[initialResponseMarker]) yield firstEvent.value;
+				while (true) {
+					const { done, value } = await asyncIterator.next();
+					if (done) break;
+					yield value;
+				}
+			} };
+		}
+		writeEventBody(unionMember, unionSchema, event) {
+			const serializer = this.serializer;
+			let eventType = unionMember;
+			let explicitPayloadMember = null;
+			let explicitPayloadContentType;
+			const isKnownSchema = (() => {
+				return unionSchema.getSchema()[4].includes(unionMember);
+			})();
+			const additionalHeaders = {};
+			if (!isKnownSchema) {
+				const [type, value] = event[unionMember];
+				eventType = type;
+				serializer.write(15, value);
+			} else {
+				const eventSchema = unionSchema.getMemberSchema(unionMember);
+				if (eventSchema.isStructSchema()) {
+					for (const [memberName, memberSchema] of eventSchema.structIterator()) {
+						const { eventHeader, eventPayload } = memberSchema.getMergedTraits();
+						if (eventPayload) explicitPayloadMember = memberName;
+						else if (eventHeader) {
+							const value = event[unionMember][memberName];
+							let type = "binary";
+							if (memberSchema.isNumericSchema()) if ((-2) ** 31 <= value && value <= 2 ** 31 - 1) type = "integer";
+							else type = "long";
+							else if (memberSchema.isTimestampSchema()) type = "timestamp";
+							else if (memberSchema.isStringSchema()) type = "string";
+							else if (memberSchema.isBooleanSchema()) type = "boolean";
+							if (value != null) {
+								additionalHeaders[memberName] = {
+									type,
+									value
+								};
+								delete event[unionMember][memberName];
+							}
+						}
+					}
+					if (explicitPayloadMember !== null) {
+						const payloadSchema = eventSchema.getMemberSchema(explicitPayloadMember);
+						if (payloadSchema.isBlobSchema()) explicitPayloadContentType = "application/octet-stream";
+						else if (payloadSchema.isStringSchema()) explicitPayloadContentType = "text/plain";
+						serializer.write(payloadSchema, event[unionMember][explicitPayloadMember]);
+					} else serializer.write(eventSchema, event[unionMember]);
+				} else if (eventSchema.isUnitSchema()) serializer.write(eventSchema, {});
+				else throw new Error("@smithy/core/event-streams - non-struct member not supported in event stream union.");
+			}
+			const messageSerialization = serializer.flush() ?? new Uint8Array();
+			return {
+				body: typeof messageSerialization === "string" ? (this.serdeContext?.utf8Decoder ?? import_dist_cjs.fromUtf8)(messageSerialization) : messageSerialization,
+				eventType,
+				explicitPayloadContentType,
+				additionalHeaders
+			};
+		}
+	};
+}) });
+
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.23.11/node_modules/@smithy/core/dist-es/submodules/event-streams/index.js
+var init_event_streams = require_dist_cjs$1.__esm({ "../../node_modules/.pnpm/@smithy+core@3.23.11/node_modules/@smithy/core/dist-es/submodules/event-streams/index.js": (() => {
+	init_EventStreamSerde();
+}) });
+
+//#endregion
+init_event_streams();
+exports.EventStreamSerde = EventStreamSerde;