@vercube/storage 0.0.1-alpha.15

package/dist/Service/Storage.d.ts

@@ -0,0 +1,66 @@
+/**
+* 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.
+*/
+export declare abstract class Storage {
+	/**
+	* Initializes the storage implementation
+	* Must be called before using any other storage operations
+	* @param {unknown} [options] - Optional initialization parameters
+	* @returns {Promise<void>} A promise that resolves when initialization is complete
+	*/
+	abstract initialize(options?: unknown): void | Promise<void>;
+	/**
+	* Retrieves a value from storage by its key
+	* @template T - The type of the stored value
+	* @param {string} key - The key to retrieve the value for
+	* @returns {Promise<T>} A promise that resolves with the stored value
+	*/
+	abstract getItem<T = unknown>(key: string): T | Promise<T>;
+	/**
+	* Stores a value in storage with the specified key
+	* @template T - The type of the value to store
+	* @template U - The type of the optional options object
+	* @param {string} key - The key under which to store the value
+	* @param {T} value - The value to store
+	* @returns {Promise<void>} A promise that resolves when the value is stored
+	*/
+	abstract setItem<
+		T = unknown,
+		U = unknown
+	>(key: string, value: T, options?: U): void | Promise<void>;
+	/**
+	* Removes a value from storage by its key
+	* @param {string} key - The key of the value to delete
+	* @returns {Promise<void>} A promise that resolves when the value is deleted
+	*/
+	abstract deleteItem(key: string): void | Promise<void>;
+	/**
+	* Checks if a value exists in storage for the given key
+	* @param {string} key - The key to check
+	* @returns {Promise<boolean>} A promise that resolves to true if the key exists, false otherwise
+	*/
+	abstract hasItem(key: string): boolean | Promise<boolean>;
+	/**
+	* Retrieves all keys currently stored in storage
+	* @returns {Promise<string[]>} A promise that resolves with an array of all stored keys
+	*/
+	abstract getKeys(): string[] | Promise<string[]>;
+	/**
+	* Removes all stored values from storage
+	* @returns {Promise<void>} A promise that resolves when all values are cleared
+	*/
+	abstract clear(): void | Promise<void>;
+	/**
+	* Gets the number of key-value pairs stored in storage
+	* @returns {Promise<number>} A promise that resolves with the number of stored items
+	*/
+	abstract size(): number | Promise<number>;
+}

package/dist/Service/StorageManager.d.ts

@@ -0,0 +1,94 @@
+import { Storage } from "./Storage.js";
+import { StorageTypes } from "../Types/StorageTypes.js";
+/**
+* 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.
+* This class handles initialization, registration, and delegation of storage operations.
+*/
+export declare class StorageManager {
+	private gContainer;
+	private gLogger;
+	/**
+	* Map of registered storage instances indexed by their names
+	*/
+	private fStorages;
+	/**
+	* Mounts a new storage instance with the specified name
+	* @param {StorageTypes.Mount} params - Mount parameters containing name and storage implementation
+	* @param {string} [params.name] - Optional name for the storage instance, defaults to 'default'
+	* @param {IOC.Newable<Storage>} params.storage - Storage implementation to mount
+	* @returns {Promise<void>} A promise that resolves when mounting is complete
+	*/
+	mount({ name, storage, initOptions }: StorageTypes.Mount): Promise<void>;
+	/**
+	* Retrieves a registered storage instance by name
+	* @param {string} name - Name of the storage instance to retrieve
+	* @returns {Storage | undefined} The storage instance if found, undefined otherwise
+	*/
+	getStorage(name?: string): Storage | undefined;
+	/**
+	* Retrieves an item from the specified storage
+	* @template T - Type of the stored value
+	* @param {StorageTypes.GetItem} params - Parameters for retrieving an item
+	* @param {string} [params.storage] - Name of the storage to retrieve from, defaults to 'default'
+	* @param {string} params.key - Key of the item to retrieve
+	* @returns {Promise<T | null>} A promise that resolves with the stored value or null if not found
+	*/
+	getItem<T = unknown>({ storage, key }: StorageTypes.GetItem): Promise<T | null>;
+	/**
+	* Stores an item in the specified storage
+	* @template T - Type of the value to store
+	* @param {StorageTypes.SetItem<T>} params - Parameters for storing an item
+	* @param {string} [params.storage] - Name of the storage to store in, defaults to 'default'
+	* @param {string} params.key - Key under which to store the value
+	* @param {T} params.value - Value to store
+	* @returns {Promise<void>} A promise that resolves when the value is stored
+	*/
+	setItem<
+		T = unknown,
+		U = unknown
+	>({ storage, key, value, options }: StorageTypes.SetItem<T, U>): Promise<void>;
+	/**
+	* Deletes an item from the specified storage
+	* @param {StorageTypes.DeleteItem} params - Parameters for deleting an item
+	* @param {string} [params.storage] - Name of the storage to delete from, defaults to 'default'
+	* @param {string} params.key - Key of the item to delete
+	* @returns {Promise<void>} A promise that resolves when the item is deleted
+	*/
+	deleteItem({ storage, key }: StorageTypes.DeleteItem): Promise<void>;
+	/**
+	* Checks if an item exists in the specified storage
+	* @param {StorageTypes.HasItem} params - Parameters for checking item existence
+	* @param {string} [params.storage] - Name of the storage to check, defaults to 'default'
+	* @param {string} params.key - Key to check for
+	* @returns {Promise<boolean>} A promise that resolves to true if the item exists, false otherwise
+	*/
+	hasItem({ storage, key }: StorageTypes.HasItem): Promise<boolean>;
+	/**
+	* Retrieves all keys from the specified storage
+	* @param {StorageTypes.GetKeys} params - Parameters for retrieving keys
+	* @param {string} [params.storage] - Name of the storage to get keys from, defaults to 'default'
+	* @returns {Promise<string[]>} A promise that resolves with an array of all keys
+	*/
+	getKeys({ storage }: StorageTypes.GetKeys): Promise<string[]>;
+	/**
+	* Clears all items from the specified storage
+	* @param {StorageTypes.Clear} params - Parameters for clearing storage
+	* @param {string} [params.storage] - Name of the storage to clear, defaults to 'default'
+	* @returns {Promise<void>} A promise that resolves when the storage is cleared
+	*/
+	clear({ storage }: StorageTypes.Clear): Promise<void>;
+	/**
+	* Gets the number of items in the specified storage
+	* @param {StorageTypes.Size} params - Parameters for getting storage size
+	* @param {string} [params.storage] - Name of the storage to get size of, defaults to 'default'
+	* @returns {Promise<number>} A promise that resolves with the number of items
+	*/
+	size({ storage }: StorageTypes.Size): Promise<number>;
+	/**
+	* Initializes all registered storage instances
+	* Called automatically with @Init() decorator
+	* @returns {Promise<void>} A promise that resolves when all storages are initialized
+	*/
+	private init;
+}

package/dist/Storages/MemoryStorage.d.ts

@@ -0,0 +1,60 @@
+import { Storage } from "../Service/Storage.js";
+/**
+* In-memory storage implementation of the Storage interface
+* Provides a simple key-value store that persists only for the duration of the application runtime
+* Useful for testing, caching, and scenarios where temporary storage is needed
+* 
+* @implements {Storage}
+*/
+export declare class MemoryStorage implements Storage {
+	/** Internal storage map to hold key-value pairs */
+	private storage;
+	/**
+	* Initializes the memory storage
+	* No initialization is needed for in-memory storage as the Map is created on instantiation
+	*/
+	initialize(): void;
+	/**
+	* Retrieves a value from memory storage by its key
+	* @template T - Type of the stored value
+	* @param {string} key - The key to retrieve the value for
+	* @returns {T} The stored value cast to type T
+	*/
+	getItem<T = unknown>(key: string): T;
+	/**
+	* Stores a value in memory storage with the specified key
+	* @template T - Type of the value to store
+	* @template U - Type of the options object
+	* @param {string} key - The key under which to store the value
+	* @param {T} value - The value to store
+	*/
+	setItem<
+		T = unknown,
+		U = unknown
+	>(key: string, value: T, options?: U): void;
+	/**
+	* Removes a value from memory storage by its key
+	* @param {string} key - The key of the value to delete
+	*/
+	deleteItem(key: string): void;
+	/**
+	* Checks if a value exists in memory storage for the given key
+	* @param {string} key - The key to check
+	* @returns {boolean} True if the key exists, false otherwise
+	*/
+	hasItem(key: string): boolean;
+	/**
+	* Retrieves all keys currently stored in memory storage
+	* @returns {string[]} Array of all stored keys
+	*/
+	getKeys(): string[];
+	/**
+	* Removes all stored values from memory storage
+	*/
+	clear(): void;
+	/**
+	* Gets the number of key-value pairs stored in memory storage
+	* @returns {number} The number of stored items
+	*/
+	size(): number;
+}

package/dist/Types/StorageTypes.d.ts

@@ -0,0 +1,36 @@
+import type { IOC } from "@vercube/di";
+import { Storage } from "../Service/Storage.js";
+export declare namespace StorageTypes {
+	interface BaseOptions {
+		storage?: string;
+	}
+	interface Mount {
+		name?: string;
+		storage: IOC.Newable<Storage>;
+		initOptions?: unknown;
+	}
+	interface Storages<T = unknown> {
+		storage: Storage;
+		initOptions?: T;
+	}
+	interface GetItem extends BaseOptions {
+		key: string;
+	}
+	interface SetItem<
+		T = unknown,
+		U = unknown
+	> extends BaseOptions {
+		key: string;
+		value: T;
+		options?: U;
+	}
+	interface DeleteItem extends BaseOptions {
+		key: string;
+	}
+	interface HasItem extends BaseOptions {
+		key: string;
+	}
+	interface GetKeys extends BaseOptions {}
+	interface Clear extends BaseOptions {}
+	interface Size extends BaseOptions {}
+}

package/dist/index.cjs

@@ -0,0 +1,239 @@
+//#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 __commonJS = (cb, mod) => function() {
+	return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+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));
+
+//#endregion
+const __vercube_di = __toESM(require("@vercube/di"));
+const __vercube_logger = __toESM(require("@vercube/logger"));
+
+//#region node_modules/.pnpm/@oxc-project+runtime@0.62.0/node_modules/@oxc-project/runtime/src/helpers/decorate.js
+var require_decorate = __commonJS({ "node_modules/.pnpm/@oxc-project+runtime@0.62.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;
+} });
+var import_decorate = __toESM(require_decorate(), 1);
+
+//#endregion
+//#region packages/storage/src/Service/StorageManager.ts
+var StorageManager = class {
+	gContainer;
+	gLogger;
+	/**
+	* Map of registered storage instances indexed by their names
+	*/
+	fStorages = new Map();
+	/**
+	* Mounts a new storage instance with the specified name
+	* @param {StorageTypes.Mount} params - Mount parameters containing name and storage implementation
+	* @param {string} [params.name] - Optional name for the storage instance, defaults to 'default'
+	* @param {IOC.Newable<Storage>} params.storage - Storage implementation to mount
+	* @returns {Promise<void>} A promise that resolves when mounting is complete
+	*/
+	async mount({ name, storage, initOptions }) {
+		this.fStorages.set(name ?? "default", {
+			storage: this.gContainer.resolve(storage),
+			initOptions
+		});
+	}
+	/**
+	* Retrieves a registered storage instance by name
+	* @param {string} name - Name of the storage instance to retrieve
+	* @returns {Storage | undefined} The storage instance if found, undefined otherwise
+	*/
+	getStorage(name = "default") {
+		return this.fStorages.get(name)?.storage ?? void 0;
+	}
+	/**
+	* Retrieves an item from the specified storage
+	* @template T - Type of the stored value
+	* @param {StorageTypes.GetItem} params - Parameters for retrieving an item
+	* @param {string} [params.storage] - Name of the storage to retrieve from, defaults to 'default'
+	* @param {string} params.key - Key of the item to retrieve
+	* @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;
+	}
+	/**
+	* Stores an item in the specified storage
+	* @template T - Type of the value to store
+	* @param {StorageTypes.SetItem<T>} params - Parameters for storing an item
+	* @param {string} [params.storage] - Name of the storage to store in, defaults to 'default'
+	* @param {string} params.key - Key under which to store the value
+	* @param {T} params.value - Value to store
+	* @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);
+	}
+	/**
+	* Deletes an item from the specified storage
+	* @param {StorageTypes.DeleteItem} params - Parameters for deleting an item
+	* @param {string} [params.storage] - Name of the storage to delete from, defaults to 'default'
+	* @param {string} params.key - Key of the item to delete
+	* @returns {Promise<void>} A promise that resolves when the item is deleted
+	*/
+	async deleteItem({ storage, key }) {
+		const storageInstance = this.getStorage(storage);
+		storageInstance?.deleteItem(key);
+	}
+	/**
+	* Checks if an item exists in the specified storage
+	* @param {StorageTypes.HasItem} params - Parameters for checking item existence
+	* @param {string} [params.storage] - Name of the storage to check, defaults to 'default'
+	* @param {string} params.key - Key to check for
+	* @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;
+	}
+	/**
+	* Retrieves all keys from the specified storage
+	* @param {StorageTypes.GetKeys} params - Parameters for retrieving keys
+	* @param {string} [params.storage] - Name of the storage to get keys from, defaults to 'default'
+	* @returns {Promise<string[]>} A promise that resolves with an array of all keys
+	*/
+	async getKeys({ storage }) {
+		const storageInstance = this.getStorage(storage);
+		return storageInstance?.getKeys() ?? [];
+	}
+	/**
+	* Clears all items from the specified storage
+	* @param {StorageTypes.Clear} params - Parameters for clearing storage
+	* @param {string} [params.storage] - Name of the storage to clear, defaults to 'default'
+	* @returns {Promise<void>} A promise that resolves when the storage is cleared
+	*/
+	async clear({ storage }) {
+		const storageInstance = this.getStorage(storage);
+		storageInstance?.clear();
+	}
+	/**
+	* Gets the number of items in the specified storage
+	* @param {StorageTypes.Size} params - Parameters for getting storage size
+	* @param {string} [params.storage] - Name of the storage to get size of, defaults to 'default'
+	* @returns {Promise<number>} A promise that resolves with the number of items
+	*/
+	async size({ storage }) {
+		const storageInstance = this.getStorage(storage);
+		return storageInstance?.size() ?? 0;
+	}
+	/**
+	* Initializes all registered storage instances
+	* Called automatically with @Init() decorator
+	* @returns {Promise<void>} A promise that resolves when all storages are initialized
+	*/
+	async init() {
+		for (const { storage, initOptions } of this.fStorages.values()) try {
+			await storage?.initialize(initOptions);
+		} catch (error) {
+			this.gLogger?.error("Vercube/StorageManager::init", error);
+		}
+	}
+};
+(0, import_decorate.default)([(0, __vercube_di.Inject)(__vercube_di.Container)], StorageManager.prototype, "gContainer", void 0);
+(0, import_decorate.default)([(0, __vercube_di.InjectOptional)(__vercube_logger.Logger)], StorageManager.prototype, "gLogger", void 0);
+(0, import_decorate.default)([(0, __vercube_di.Init)()], StorageManager.prototype, "init", null);
+
+//#endregion
+//#region packages/storage/src/Service/Storage.ts
+var Storage = class {};
+
+//#endregion
+//#region packages/storage/src/Storages/MemoryStorage.ts
+var MemoryStorage = class {
+	/** Internal storage map to hold key-value pairs */
+	storage = new Map();
+	/**
+	* Initializes the memory storage
+	* No initialization is needed for in-memory storage as the Map is created on instantiation
+	*/
+	initialize() {}
+	/**
+	* Retrieves a value from memory storage by its key
+	* @template T - Type of the stored value
+	* @param {string} key - The key to retrieve the value for
+	* @returns {T} The stored value cast to type T
+	*/
+	getItem(key) {
+		return this.storage.get(key);
+	}
+	/**
+	* Stores a value in memory storage with the specified key
+	* @template T - Type of the value to store
+	* @template U - Type of the options object
+	* @param {string} key - The key under which to store the value
+	* @param {T} value - The value to store
+	*/
+	setItem(key, value, options) {
+		this.storage.set(key, value);
+	}
+	/**
+	* Removes a value from memory storage by its key
+	* @param {string} key - The key of the value to delete
+	*/
+	deleteItem(key) {
+		this.storage.delete(key);
+	}
+	/**
+	* Checks if a value exists in memory storage for the given key
+	* @param {string} key - The key to check
+	* @returns {boolean} True if the key exists, false otherwise
+	*/
+	hasItem(key) {
+		return this.storage.has(key);
+	}
+	/**
+	* Retrieves all keys currently stored in memory storage
+	* @returns {string[]} Array of all stored keys
+	*/
+	getKeys() {
+		return [...this.storage.keys()];
+	}
+	/**
+	* Removes all stored values from memory storage
+	*/
+	clear() {
+		this.storage.clear();
+	}
+	/**
+	* Gets the number of key-value pairs stored in memory storage
+	* @returns {number} The number of stored items
+	*/
+	size() {
+		return this.storage.size;
+	}
+};
+
+//#endregion
+exports.MemoryStorage = MemoryStorage
+exports.Storage = Storage
+exports.StorageManager = StorageManager

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./Service/StorageManager.js";
+export * from "./Service/Storage.js";
+export * from "./Storages/MemoryStorage.js";
+export * from "./Types/StorageTypes.js";

package/dist/index.mjs

@@ -0,0 +1,207 @@
+import { Container, Init, Inject, InjectOptional } from "@vercube/di";
+import { Logger } from "@vercube/logger";
+
+//#region node_modules/.pnpm/@oxc-project+runtime@0.62.0/node_modules/@oxc-project/runtime/src/helpers/esm/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 packages/storage/src/Service/StorageManager.ts
+var StorageManager = class {
+	gContainer;
+	gLogger;
+	/**
+	* Map of registered storage instances indexed by their names
+	*/
+	fStorages = new Map();
+	/**
+	* Mounts a new storage instance with the specified name
+	* @param {StorageTypes.Mount} params - Mount parameters containing name and storage implementation
+	* @param {string} [params.name] - Optional name for the storage instance, defaults to 'default'
+	* @param {IOC.Newable<Storage>} params.storage - Storage implementation to mount
+	* @returns {Promise<void>} A promise that resolves when mounting is complete
+	*/
+	async mount({ name, storage, initOptions }) {
+		this.fStorages.set(name ?? "default", {
+			storage: this.gContainer.resolve(storage),
+			initOptions
+		});
+	}
+	/**
+	* Retrieves a registered storage instance by name
+	* @param {string} name - Name of the storage instance to retrieve
+	* @returns {Storage | undefined} The storage instance if found, undefined otherwise
+	*/
+	getStorage(name = "default") {
+		return this.fStorages.get(name)?.storage ?? void 0;
+	}
+	/**
+	* Retrieves an item from the specified storage
+	* @template T - Type of the stored value
+	* @param {StorageTypes.GetItem} params - Parameters for retrieving an item
+	* @param {string} [params.storage] - Name of the storage to retrieve from, defaults to 'default'
+	* @param {string} params.key - Key of the item to retrieve
+	* @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;
+	}
+	/**
+	* Stores an item in the specified storage
+	* @template T - Type of the value to store
+	* @param {StorageTypes.SetItem<T>} params - Parameters for storing an item
+	* @param {string} [params.storage] - Name of the storage to store in, defaults to 'default'
+	* @param {string} params.key - Key under which to store the value
+	* @param {T} params.value - Value to store
+	* @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);
+	}
+	/**
+	* Deletes an item from the specified storage
+	* @param {StorageTypes.DeleteItem} params - Parameters for deleting an item
+	* @param {string} [params.storage] - Name of the storage to delete from, defaults to 'default'
+	* @param {string} params.key - Key of the item to delete
+	* @returns {Promise<void>} A promise that resolves when the item is deleted
+	*/
+	async deleteItem({ storage, key }) {
+		const storageInstance = this.getStorage(storage);
+		storageInstance?.deleteItem(key);
+	}
+	/**
+	* Checks if an item exists in the specified storage
+	* @param {StorageTypes.HasItem} params - Parameters for checking item existence
+	* @param {string} [params.storage] - Name of the storage to check, defaults to 'default'
+	* @param {string} params.key - Key to check for
+	* @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;
+	}
+	/**
+	* Retrieves all keys from the specified storage
+	* @param {StorageTypes.GetKeys} params - Parameters for retrieving keys
+	* @param {string} [params.storage] - Name of the storage to get keys from, defaults to 'default'
+	* @returns {Promise<string[]>} A promise that resolves with an array of all keys
+	*/
+	async getKeys({ storage }) {
+		const storageInstance = this.getStorage(storage);
+		return storageInstance?.getKeys() ?? [];
+	}
+	/**
+	* Clears all items from the specified storage
+	* @param {StorageTypes.Clear} params - Parameters for clearing storage
+	* @param {string} [params.storage] - Name of the storage to clear, defaults to 'default'
+	* @returns {Promise<void>} A promise that resolves when the storage is cleared
+	*/
+	async clear({ storage }) {
+		const storageInstance = this.getStorage(storage);
+		storageInstance?.clear();
+	}
+	/**
+	* Gets the number of items in the specified storage
+	* @param {StorageTypes.Size} params - Parameters for getting storage size
+	* @param {string} [params.storage] - Name of the storage to get size of, defaults to 'default'
+	* @returns {Promise<number>} A promise that resolves with the number of items
+	*/
+	async size({ storage }) {
+		const storageInstance = this.getStorage(storage);
+		return storageInstance?.size() ?? 0;
+	}
+	/**
+	* Initializes all registered storage instances
+	* Called automatically with @Init() decorator
+	* @returns {Promise<void>} A promise that resolves when all storages are initialized
+	*/
+	async init() {
+		for (const { storage, initOptions } of this.fStorages.values()) try {
+			await storage?.initialize(initOptions);
+		} catch (error) {
+			this.gLogger?.error("Vercube/StorageManager::init", error);
+		}
+	}
+};
+__decorate([Inject(Container)], StorageManager.prototype, "gContainer", void 0);
+__decorate([InjectOptional(Logger)], StorageManager.prototype, "gLogger", void 0);
+__decorate([Init()], StorageManager.prototype, "init", null);
+
+//#endregion
+//#region packages/storage/src/Service/Storage.ts
+var Storage = class {};
+
+//#endregion
+//#region packages/storage/src/Storages/MemoryStorage.ts
+var MemoryStorage = class {
+	/** Internal storage map to hold key-value pairs */
+	storage = new Map();
+	/**
+	* Initializes the memory storage
+	* No initialization is needed for in-memory storage as the Map is created on instantiation
+	*/
+	initialize() {}
+	/**
+	* Retrieves a value from memory storage by its key
+	* @template T - Type of the stored value
+	* @param {string} key - The key to retrieve the value for
+	* @returns {T} The stored value cast to type T
+	*/
+	getItem(key) {
+		return this.storage.get(key);
+	}
+	/**
+	* Stores a value in memory storage with the specified key
+	* @template T - Type of the value to store
+	* @template U - Type of the options object
+	* @param {string} key - The key under which to store the value
+	* @param {T} value - The value to store
+	*/
+	setItem(key, value, options) {
+		this.storage.set(key, value);
+	}
+	/**
+	* Removes a value from memory storage by its key
+	* @param {string} key - The key of the value to delete
+	*/
+	deleteItem(key) {
+		this.storage.delete(key);
+	}
+	/**
+	* Checks if a value exists in memory storage for the given key
+	* @param {string} key - The key to check
+	* @returns {boolean} True if the key exists, false otherwise
+	*/
+	hasItem(key) {
+		return this.storage.has(key);
+	}
+	/**
+	* Retrieves all keys currently stored in memory storage
+	* @returns {string[]} Array of all stored keys
+	*/
+	getKeys() {
+		return [...this.storage.keys()];
+	}
+	/**
+	* Removes all stored values from memory storage
+	*/
+	clear() {
+		this.storage.clear();
+	}
+	/**
+	* Gets the number of key-value pairs stored in memory storage
+	* @returns {number} The number of stored items
+	*/
+	size() {
+		return this.storage.size;
+	}
+};
+
+//#endregion
+export { MemoryStorage, Storage, StorageManager };

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@vercube/storage",
+  "version": "0.0.1-alpha.15",
+  "description": "Storage module for Vercube framework",
+  "repository": "@vercube/storage",
+  "license": "MIT",
+  "sideEffects": false,
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@vercube/di": "0.0.1-alpha.15",
+    "@vercube/logger": "0.0.1-alpha.15"
+  },
+  "devDependencies": {},
+  "publishConfig": {
+    "access": "public"
+  }
+}