@vercube/storage 0.0.22 → 0.0.24

package/dist/Storage-Cr72sGff.mjs

@@ -0,0 +1,16 @@
+//#region src/Service/Storage.ts
+/**
+* Abstract base class for storage implementations
+* Provides a common interface for different storage providers
+*
+* @abstract
+* @class Storage
+* @description
+* The Storage class defines a standard interface for storing and retrieving data.
+* It supports basic operations like get, set, delete, and querying storage state.
+* Concrete implementations must provide the actual storage mechanism.
+*/
+var Storage = class {};
+
+//#endregion
+export { Storage };

package/dist/event-streams-CEo-hsfG.mjs

@@ -0,0 +1,179 @@
+import { SCHEMA, __esm, __toESM, init_schema, require_dist_cjs } from "./schema-DfAlCaU9.mjs";
+
+//#region ../../node_modules/.pnpm/@smithy+core@3.11.1/node_modules/@smithy/core/dist-es/submodules/event-streams/EventStreamSerde.js
+var import_dist_cjs, EventStreamSerde;
+var init_EventStreamSerde = __esm({ "../../node_modules/.pnpm/@smithy+core@3.11.1/node_modules/@smithy/core/dist-es/submodules/event-streams/EventStreamSerde.js": (() => {
+	init_schema();
+	import_dist_cjs = /* @__PURE__ */ __toESM(require_dist_cjs());
+	EventStreamSerde = class {
+		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);
+			unionSchema.getMemberSchemas();
+			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";
+				}) ?? "";
+				if (unionMember === "initial-response") {
+					const dataObject = await this.deserializer.read(responseSchema, event[unionMember].body);
+					delete dataObject[eventStreamMember];
+					return {
+						[initialResponseMarker]: true,
+						...dataObject
+					};
+				} else if (unionMember in memberSchemas) {
+					const eventStreamSchema = memberSchemas[unionMember];
+					return { [unionMember]: await this.deserializer.read(eventStreamSchema, event[unionMember].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 = unionSchema.hasMemberSchema(unionMember);
+			const additionalHeaders = {};
+			if (!isKnownSchema) {
+				const [type, value] = event[unionMember];
+				eventType = type;
+				serializer.write(SCHEMA.DOCUMENT, 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;
+							break;
+						} 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 throw new Error("@smithy/core/event-streams - non-struct member not supported in event stream union.");
+			}
+			const messageSerialization = serializer.flush();
+			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.11.1/node_modules/@smithy/core/dist-es/submodules/event-streams/index.js
+var init_event_streams = __esm({ "../../node_modules/.pnpm/@smithy+core@3.11.1/node_modules/@smithy/core/dist-es/submodules/event-streams/index.js": (() => {
+	init_EventStreamSerde();
+}) });
+
+//#endregion
+init_event_streams();
+export { EventStreamSerde };

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-import { Storage } from "./Storage-DZ-jzAK_.mjs";
+import { Storage } from "./Storage-D-QyQ5of.mjs";
 import { IOC } from "@vercube/di";
 
 //#region src/Types/StorageTypes.d.ts

package/dist/index.mjs

@@ -1,21 +1,17 @@
-import { __commonJS, __toESM } from "./chunk-UoOzN6Vc.mjs";
+import { Storage } from "./Storage-Cr72sGff.mjs";
 import { Container, Init, Inject, InjectOptional } from "@vercube/di";
 import { Logger } from "@vercube/logger";
 
-//#region ../../node_modules/.pnpm/@oxc-project+runtime@0.81.0/node_modules/@oxc-project/runtime/src/helpers/decorate.js
-var require_decorate = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/@oxc-project+runtime@0.81.0/node_modules/@oxc-project/runtime/src/helpers/decorate.js": ((exports, module) => {
-	function __decorate(decorators, target, key, desc) {
-		var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-		if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-		else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-		return c > 3 && r && Object.defineProperty(target, key, r), r;
-	}
-	module.exports = __decorate, module.exports.__esModule = true, module.exports["default"] = module.exports;
-}) });
+//#region \0@oxc-project+runtime@0.90.0/helpers/decorate.js
+function __decorate(decorators, target, key, desc) {
+	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+	else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+	return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
 
 //#endregion
 //#region src/Service/StorageManager.ts
-var import_decorate = /* @__PURE__ */ __toESM(require_decorate(), 1);
 /**
 * Manages multiple storage instances and provides a unified interface for storage operations.
 * Each storage instance is identified by a unique name and implements the Storage interface.
@@ -58,8 +54,7 @@ var StorageManager = class {
 	* @returns {Promise<T | null>} A promise that resolves with the stored value or null if not found
 	*/
 	async getItem({ storage, key }) {
-		const storageInstance = this.getStorage(storage);
-		return storageInstance?.getItem(key) ?? null;
+		return this.getStorage(storage)?.getItem(key) ?? null;
 	}
 	/**
 	* Stores an item in the specified storage
@@ -71,8 +66,7 @@ var StorageManager = class {
 	* @returns {Promise<void>} A promise that resolves when the value is stored
 	*/
 	async setItem({ storage, key, value, options }) {
-		const storageInstance = this.getStorage(storage);
-		storageInstance?.setItem(key, value, options);
+		this.getStorage(storage)?.setItem(key, value, options);
 	}
 	/**
 	* Deletes an item from the specified storage
@@ -82,8 +76,7 @@ var StorageManager = class {
 	* @returns {Promise<void>} A promise that resolves when the item is deleted
 	*/
 	async deleteItem({ storage, key }) {
-		const storageInstance = this.getStorage(storage);
-		storageInstance?.deleteItem(key);
+		this.getStorage(storage)?.deleteItem(key);
 	}
 	/**
 	* Checks if an item exists in the specified storage
@@ -93,8 +86,7 @@ var StorageManager = class {
 	* @returns {Promise<boolean>} A promise that resolves to true if the item exists, false otherwise
 	*/
 	async hasItem({ storage, key }) {
-		const storageInstance = this.getStorage(storage);
-		return storageInstance?.hasItem(key) ?? false;
+		return this.getStorage(storage)?.hasItem(key) ?? false;
 	}
 	/**
 	* Retrieves all keys from the specified storage
@@ -103,8 +95,7 @@ var StorageManager = class {
 	* @returns {Promise<string[]>} A promise that resolves with an array of all keys
 	*/
 	async getKeys({ storage }) {
-		const storageInstance = this.getStorage(storage);
-		return storageInstance?.getKeys() ?? [];
+		return this.getStorage(storage)?.getKeys() ?? [];
 	}
 	/**
 	* Clears all items from the specified storage
@@ -113,8 +104,7 @@ var StorageManager = class {
 	* @returns {Promise<void>} A promise that resolves when the storage is cleared
 	*/
 	async clear({ storage }) {
-		const storageInstance = this.getStorage(storage);
-		storageInstance?.clear();
+		this.getStorage(storage)?.clear();
 	}
 	/**
 	* Gets the number of items in the specified storage
@@ -123,8 +113,7 @@ var StorageManager = class {
 	* @returns {Promise<number>} A promise that resolves with the number of items
 	*/
 	async size({ storage }) {
-		const storageInstance = this.getStorage(storage);
-		return storageInstance?.size() ?? 0;
+		return this.getStorage(storage)?.size() ?? 0;
 	}
 	/**
 	* Initializes all registered storage instances
@@ -139,24 +128,9 @@ var StorageManager = class {
 		}
 	}
 };
-(0, import_decorate.default)([Inject(Container)], StorageManager.prototype, "gContainer", void 0);
-(0, import_decorate.default)([InjectOptional(Logger)], StorageManager.prototype, "gLogger", void 0);
-(0, import_decorate.default)([Init()], StorageManager.prototype, "init", null);
-
-//#endregion
-//#region src/Service/Storage.ts
-/**
-* Abstract base class for storage implementations
-* Provides a common interface for different storage providers
-* 
-* @abstract
-* @class Storage
-* @description
-* The Storage class defines a standard interface for storing and retrieving data.
-* It supports basic operations like get, set, delete, and querying storage state.
-* Concrete implementations must provide the actual storage mechanism.
-*/
-var Storage = class {};
+__decorate([Inject(Container)], StorageManager.prototype, "gContainer", void 0);
+__decorate([InjectOptional(Logger)], StorageManager.prototype, "gLogger", void 0);
+__decorate([Init()], StorageManager.prototype, "init", null);
 
 //#endregion
 export { Storage, StorageManager };