@warlock.js/core 4.0.174 → 4.1.2

package/esm/router/types.d.mts

@@ -0,0 +1,260 @@
+import { Request } from "../http/request.mjs";
+import { Response } from "../http/response.mjs";
+import { ReturnedResponse } from "../http/types.mjs";
+import { ResponseSchema } from "../resource/types.mjs";
+import { ObjectValidator } from "@warlock.js/seal";
+import { GenericObject } from "@mongez/reinforcements";
+import { RouteShorthandOptions } from "fastify";
+
+//#region ../../@warlock.js/core/src/router/types.d.ts
+/**
+ * Middleware response
+ */
+type MiddlewareResponse = ReturnedResponse | undefined | void;
+/**
+ * Middleware method
+ * Receives the request and response objects
+ * And returns a response object or undefined if the request should continue
+ */
+type Middleware<MiddlewareRequest extends Request = Request> = {
+  (request: MiddlewareRequest, response: Response): MiddlewareResponse;
+};
+type RouterGroupCallback = () => void;
+type RequestHandlerType = RequestHandler<any> | [GenericObject, string];
+/**
+ * Resource standard methods
+ */
+type ResourceMethod = "list" | "get" | "create" | "update" | "delete" | "patch";
+type RestfulMiddleware = Record<string, [Middleware]>;
+type RequestHandlerValidation<TRequest extends Request = Request> = {
+  /**
+   * Validation custom message
+   */
+  validate?: Middleware<TRequest>;
+  /**
+   * Define what should be validated
+   * If not passed, it will be validating only body and query
+   */
+  validating?: ("body" | "query" | "params" | "headers")[];
+  /**
+   * Validation schema
+   */
+  schema?: ObjectValidator;
+};
+interface RequestControllerContract {
+  /**
+   * Request object
+   */
+  request: Request;
+  /**
+   * Response object
+   */
+  response: Response;
+  /**
+   * Request Handler execution
+   */
+  execute(): Promise<ReturnedResponse>;
+  /**
+   * Request description
+   */
+  description?: string;
+  /**
+   * Request validation middleware
+   */
+  middleware?: () => Promise<MiddlewareResponse> | MiddlewareResponse;
+}
+type RequestHandler<TRequest extends Request = Request> = {
+  /**
+   * Function Declaration
+   */
+  (request: TRequest, response: Response): ReturnedResponse | void;
+  /**
+   * Validation static object property which can be optional
+   */
+  validation?: RequestHandlerValidation<TRequest>;
+  /**
+   * Request Handler Description
+   */
+  description?: string;
+  /**
+   * Response schema for documentation / OpenAPI generation.
+   * Keyed by HTTP status code. Each entry declares the expected response body shape.
+   */
+  responseSchema?: ResponseSchema;
+};
+interface RouteOptions {
+  /**
+   * Route middleware
+   */
+  middleware?: Middleware[];
+  /**
+   * Middleware precedence to be applied before grouped middleware or after it
+   */
+  middlewarePrecedence?: "before" | "after";
+  /**
+   * Route name
+   */
+  name?: string;
+  /**
+   * Route description
+   * Could be used for generating documentation
+   */
+  description?: string;
+  /**
+   * Request server options
+   */
+  serverOptions?: RouteShorthandOptions;
+  /**
+   * Set route label
+   * Will be used for generating documentation
+   * If not set, then Warlock will try to generate a label from the route path
+   */
+  label?: string;
+  /**
+   * Whether it is part of restful routes
+   */
+  restful?: boolean;
+  /**
+   * Mark this route as a page route that will be handled by React SSR
+   */
+  isPage?: boolean;
+  /**
+   * Rate limit options for this route
+   */
+  rateLimit?: {
+    /**
+     * Max number of requests within the time window
+     */
+    max: number;
+    /**
+     * Time window in milliseconds
+     */
+    timeWindow: number;
+    /**
+     * Error message when rate limit is exceeded
+     */
+    errorMessage?: string;
+  };
+}
+type RequestMethod = "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "OPTIONS" | "HEAD" | "all";
+/**
+ * Route Object
+ */
+type Route = RouteOptions & {
+  /**
+   * Route method
+   */
+  method: RequestMethod;
+  /**
+   * Route source file (Relative path)
+   */
+  sourceFile: string;
+  /**
+   * Route path
+   */
+  path: string;
+  /**
+   * Route handler Can be a function
+   * And als can have a `validation` object as a static property of the handler
+   */
+  handler: RequestHandler;
+  /**
+   * Path prefix
+   * Kindly note the prefix is auto added by the router and it should be added to the path itself
+   * this will be used for generating the documentation
+   */
+  $prefix: string;
+  /**
+   * Path prefix Stack
+   * Kindly note the prefix is auto added by the router and it should be added to the path itself
+   * this will be used for generating the documentation
+   */
+  $prefixStack: string[];
+  /**
+   * Rate limit
+   */
+  rateLimit?: RouteOptions["rateLimit"];
+};
+type PartialPick<T, F extends keyof T> = Omit<T, F> & Partial<Pick<T, F>>;
+/**
+ * Grouped routes options
+ */
+type GroupedRoutesOptions = {
+  /**
+   * Middlewares to be applied to all routes
+   */
+  middleware?: Middleware[];
+  /**
+   * Route prefix
+   */
+  prefix?: string;
+  /**
+   * Route name
+   * This will be added to each route as a name prefix
+   */
+  name?: string;
+};
+/** Route resource */
+type RouteResource = {
+  /**
+   * list route
+   */
+  list?: RequestHandler;
+  /**
+   * Single resource route
+   */
+  get?: RequestHandler;
+  /**
+   * Create resource route
+   */
+  create?: RequestHandler;
+  /**
+   * Update resource route
+   */
+  update?: RequestHandler;
+  /**
+   * Patch resource route
+   */
+  patch?: RequestHandler;
+  /**
+   * Delete resource route
+   */
+  delete?: RequestHandler;
+  /**
+   * Delete Multiple Records
+   */
+  bulkDelete?: RequestHandler;
+  /**
+   * Validation object
+   */
+  validation?: {
+    /**
+     * Apply validation on create|update|patch combined
+     */
+    all?: RequestHandlerValidation<any>;
+    /**
+     * Create validation object
+     */
+    create?: RequestHandlerValidation<any>;
+    /**
+     * Update validation object
+     */
+    update?: RequestHandlerValidation<any>;
+    /**
+     * Patch validation object
+     */
+    patch?: RequestHandlerValidation<any>;
+  };
+};
+type RouterStacks = {
+  prefix: string[];
+  name: string[];
+  middleware: Middleware[];
+  /**
+   * Source file path for routes being added (for HMR route tracking)
+   */
+  sourceFile?: string;
+};
+//#endregion
+export { GroupedRoutesOptions, Middleware, MiddlewareResponse, PartialPick, RequestControllerContract, RequestHandler, RequestHandlerType, RequestHandlerValidation, RequestMethod, ResourceMethod, RestfulMiddleware, Route, RouteOptions, RouteResource, RouterGroupCallback, RouterStacks };
+//# sourceMappingURL=types.d.mts.map

package/esm/router/types.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.mts","names":[],"sources":["../../../../../../@warlock.js/core/src/router/types.ts"],"mappings":";;;;;;;;;;;;KASY,kBAAA,GAAqB,gBAAgB;;AAAjD;;;;KAOY,UAAA,2BAAqC,OAAA,GAAU,OAAA;EAAA,CACxD,OAAA,EAAS,iBAAA,EAAmB,QAAA,EAAU,QAAA,GAAW,kBAAA;AAAA;AAAA,KAGxC,mBAAA;AAAA,KAEA,kBAAA,GAAqB,cAAA,SAAuB,aAAa;;;;KAKzD,cAAA;AAAA,KAEA,iBAAA,GAAoB,MAAM,UAAU,UAAA;AAAA,KAEpC,wBAAA,kBAA0C,OAAA,GAAU,OAAA;EAfzC;;;EAmBrB,QAAA,GAAW,UAAA,CAAW,QAAA;EAlBrB;;;;EAuBD,UAAA;EAvBoE;AAGtE;;EAwBE,MAAA,GAAS,eAAA;AAAA;AAAA,UAGM,yBAAA;EAzBL;;;EA6BV,OAAA,EAAS,OAAA;EA7B0D;AAKrE;;EA4BE,QAAA,EAAU,QAAA;EA5Bc;AAAA;AAE1B;EA8BE,OAAA,IAAW,OAAA,CAAQ,gBAAA;;;AA9BqC;EAkCxD,WAAA;EAhCkC;;;EAoClC,UAAA,SAAmB,OAAA,CAAQ,kBAAA,IAAsB,kBAAA;AAAA;AAAA,KAGvC,cAAA,kBAAgC,OAAA,GAAU,OAAA;EA1B3C;;;EAAA,CA8BR,OAAA,EAAS,QAAA,EAAU,QAAA,EAAU,QAAA,GAAW,gBAAA;EA3CW;;;EAgDpD,UAAA,GAAa,wBAAA,CAAyB,QAAA;EA5ChB;;;EAiDtB,WAAA;EAxCwB;AAAA;AAG1B;;EA2CE,cAAA,GAAiB,cAAA;AAAA;AAAA,UAGF,YAAA;EAlCI;;;EAsCnB,UAAA,GAAa,UAAA;EA9BoC;;;EAkCjD,oBAAA;EAlDS;;;EAsDT,IAAA;EA9CW;;;;EAmDX,WAAA;EA3C2B;;;EA+C3B,aAAA,GAAgB,qBAAqB;EA5C3B;;;;;EAkDV,KAAA;EA9C8B;;;EAkD9B,OAAA;EAlCiB;;;EAsCjB,MAAA;EA1D0C;;;EA8D1C,SAAA;IA1D8B;;;IA8D5B,GAAA;IAzDW;;;IA6DX,UAAA;IAlDe;;AAAc;IAsD7B,YAAA;EAAA;AAAA;AAAA,KAIQ,aAAA;;;;KAaA,KAAA,GAAQ,YAAA;EAnDlB;;;EAuDA,MAAA,EAAQ,aAAA;EAzCR;;;EA6CA,UAAA;EA7BE;;;EAiCF,IAAA;EAzBU;;;;EA8BV,OAAA,EAAS,cAAA;EAjBC;;;;;EAuBV,OAAA;EAUY;;;;;EAJZ,YAAA;EArBA;;;EAyBA,SAAA,GAAY,YAAA;AAAA;AAAA,KAGF,WAAA,oBAA+B,CAAA,IAAK,IAAA,CAAK,CAAA,EAAG,CAAA,IAAK,OAAA,CAAQ,IAAA,CAAK,CAAA,EAAG,CAAA;;;;KAKjE,oBAAA;EALA;;;EASV,UAAA,GAAa,UAAU;EAT4B;;;EAanD,MAAA;EAb2E;;;;EAkB3E,IAAA;AAAA;;KAIU,aAAA;EAtBoC;;;EA0B9C,IAAA,GAAO,cAAA;EA1B4D;;;EA8BnE,GAAA,GAAM,cAAA;EA9BsE;AAK9E;;EA6BE,MAAA,GAAS,cAAA;EAzBc;;;EA6BvB,MAAA,GAAS,cAAA;EApBT;;AAAI;EAwBJ,KAAA,GAAQ,cAAA;EApBe;;;EAwBvB,MAAA,GAAS,cAAA;EAZA;;;EAgBT,UAAA,GAAa,cAAA;EAAA;;;EAIb,UAAA;IAgBU;;;IAZR,GAAA,GAAM,wBAAA;IAhCD;;;IAoCL,MAAA,GAAS,wBAAA;IA5BF;;;IAgCP,MAAA,GAAS,wBAAA;IAxBH;;;IA4BN,KAAA,GAAQ,wBAAA;EAAA;AAAA;AAAA,KAIA,YAAA;EACV,MAAA;EACA,IAAA;EACA,UAAA,EAAY,UAAU;EAXpB;;;EAeF,UAAA;AAAA"}

package/esm/socket/index.d.mts

@@ -0,0 +1,2 @@
+import { SocketOptions } from "./types.mjs";
+import { getSocketServer } from "./utils.mjs";

package/esm/socket/index.mjs

@@ -0,0 +1,3 @@
+import { getSocketServer } from "./utils.mjs";
+
+export {  };

package/esm/socket/types.d.mts

@@ -0,0 +1,19 @@
+import { ServerOptions } from "node:http";
+
+//#region ../../@warlock.js/core/src/socket/types.d.ts
+/**
+ * Socket options
+ */
+type SocketOptions = {
+  /**
+   * Http Port, use it if the http is not enabled in the project
+   */
+  port?: number;
+  /**
+   * Socket.IO options
+   */
+  options?: ServerOptions;
+};
+//#endregion
+export { SocketOptions };
+//# sourceMappingURL=types.d.mts.map

package/esm/socket/types.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.mts","names":[],"sources":["../../../../../../@warlock.js/core/src/socket/types.ts"],"mappings":";;;;;AAKA;KAAY,aAAA;;;;EAIV,IAAA;EAIU;;AAAa;EAAvB,OAAA,GAAU,aAAa;AAAA"}

package/esm/socket/utils.d.mts

@@ -0,0 +1,10 @@
+import { Server } from "socket.io";
+
+//#region ../../@warlock.js/core/src/socket/utils.d.ts
+/**
+ * Get socket server instance
+ */
+declare function getSocketServer(): Server | null;
+//#endregion
+export { getSocketServer };
+//# sourceMappingURL=utils.d.mts.map

package/esm/socket/utils.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.mts","names":[],"sources":["../../../../../../@warlock.js/core/src/socket/utils.ts"],"mappings":";;;;;AAMA;iBAAgB,eAAA,CAAA,GAAmB,MAAM"}

package/esm/socket/utils.mjs

@@ -0,0 +1,14 @@
+import { container } from "../container/index.mjs";
+
+//#region ../../@warlock.js/core/src/socket/utils.ts
+/**
+* Get socket server instance
+*/
+function getSocketServer() {
+	if (container.has("socket")) return container.get("socket");
+	return null;
+}
+
+//#endregion
+export { getSocketServer };
+//# sourceMappingURL=utils.mjs.map

package/esm/socket/utils.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.mjs","names":[],"sources":["../../../../../../@warlock.js/core/src/socket/utils.ts"],"sourcesContent":["import { type Server } from \"socket.io\";\nimport { container } from \"../container\";\n\n/**\n * Get socket server instance\n */\nexport function getSocketServer(): Server | null {\n  if (container.has(\"socket\")) {\n    return container.get(\"socket\");\n  }\n\n  return null;\n}\n"],"mappings":";;;;;;AAMA,SAAgB,kBAAiC;CAC/C,IAAI,UAAU,IAAI,QAAQ,GACxB,OAAO,UAAU,IAAI,QAAQ;CAG/B,OAAO;AACT"}

package/esm/storage/config.d.mts

@@ -0,0 +1,19 @@
+import { CloudStorageDriverOptions, LocalStorageDriverOptions, R2StorageDriverOptions, StorageConfigurations, StorageDriverConfig } from "./types.mjs";
+import { S3ClientConfig } from "@aws-sdk/client-s3";
+
+//#region ../../@warlock.js/core/src/storage/config.d.ts
+/**
+ * Get storage configuration
+ */
+declare function storageConfig(): StorageConfigurations;
+declare function storageConfig<T = any>(key: string): T;
+declare function storageConfig<T = any>(key: string, defaultValue: T): T;
+declare const storageConfigurations: {
+  local: (options: LocalStorageDriverOptions) => StorageDriverConfig;
+  aws: (options: CloudStorageDriverOptions & S3ClientConfig) => StorageDriverConfig;
+  r2: (options: R2StorageDriverOptions & S3ClientConfig) => StorageDriverConfig;
+  spaces: (options: CloudStorageDriverOptions & S3ClientConfig) => StorageDriverConfig;
+};
+//#endregion
+export { storageConfig, storageConfigurations };
+//# sourceMappingURL=config.d.mts.map

package/esm/storage/config.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.mts","names":[],"sources":["../../../../../../@warlock.js/core/src/storage/config.ts"],"mappings":";;;;;;AAaA;iBAAgB,aAAA,CAAA,GAAiB,qBAAqB;AAAA,iBACtC,aAAA,SAAA,CAAuB,GAAA,WAAc,CAAC;AAAA,iBACtC,aAAA,SAAA,CAAuB,GAAA,UAAa,YAAA,EAAc,CAAA,GAAI,CAAC;AAAA,cAS1D,qBAAA;mBACM,yBAAA,KAA4B,mBAAA;iBAM9B,yBAAA,GAA4B,cAAA,KAAiB,mBAAA;gBAM9C,sBAAA,GAAyB,cAAA,KAAiB,mBAAA;oBAMtC,yBAAA,GAA4B,cAAA,KAAiB,mBAAA;AAAA"}

package/esm/storage/config.mjs

@@ -0,0 +1,38 @@
+import { config } from "../config/config-getter.mjs";
+import "../config/index.mjs";
+
+//#region ../../@warlock.js/core/src/storage/config.ts
+function storageConfig(key, defaultValue) {
+	if (!key) return config.get("storage");
+	return config.get(`storage.${key}`, defaultValue);
+}
+const storageConfigurations = {
+	local: (options) => {
+		return {
+			driver: "local",
+			...options
+		};
+	},
+	aws: (options) => {
+		return {
+			driver: "s3",
+			...options
+		};
+	},
+	r2: (options) => {
+		return {
+			driver: "r2",
+			...options
+		};
+	},
+	spaces: (options) => {
+		return {
+			driver: "spaces",
+			...options
+		};
+	}
+};
+
+//#endregion
+export { storageConfig, storageConfigurations };
+//# sourceMappingURL=config.mjs.map

package/esm/storage/config.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.mjs","names":[],"sources":["../../../../../../@warlock.js/core/src/storage/config.ts"],"sourcesContent":["import type { S3ClientConfig } from \"@aws-sdk/client-s3\";\nimport { config } from \"../config\";\nimport type {\n  CloudStorageDriverOptions,\n  LocalStorageDriverOptions,\n  R2StorageDriverOptions,\n  StorageConfigurations,\n  StorageDriverConfig,\n} from \"./types\";\n\n/**\n * Get storage configuration\n */\nexport function storageConfig(): StorageConfigurations;\nexport function storageConfig<T = any>(key: string): T;\nexport function storageConfig<T = any>(key: string, defaultValue: T): T;\nexport function storageConfig(key?: string, defaultValue?: any): any {\n  if (!key) {\n    return config.get(\"storage\");\n  }\n\n  return config.get(`storage.${key}`, defaultValue);\n}\n\nexport const storageConfigurations = {\n  local: (options: LocalStorageDriverOptions): StorageDriverConfig => {\n    return {\n      driver: \"local\",\n      ...options,\n    };\n  },\n  aws: (options: CloudStorageDriverOptions & S3ClientConfig): StorageDriverConfig => {\n    return {\n      driver: \"s3\",\n      ...options,\n    };\n  },\n  r2: (options: R2StorageDriverOptions & S3ClientConfig): StorageDriverConfig => {\n    return {\n      driver: \"r2\",\n      ...options,\n    };\n  },\n  spaces: (options: CloudStorageDriverOptions & S3ClientConfig): StorageDriverConfig => {\n    return {\n      driver: \"spaces\",\n      ...options,\n    };\n  },\n};\n"],"mappings":";;;;AAgBA,SAAgB,cAAc,KAAc,cAAyB;CACnE,IAAI,CAAC,KACH,OAAO,OAAO,IAAI,SAAS;CAG7B,OAAO,OAAO,IAAI,WAAW,OAAO,YAAY;AAClD;AAEA,MAAa,wBAAwB;CACnC,QAAQ,YAA4D;EAClE,OAAO;GACL,QAAQ;GACR,GAAG;EACL;CACF;CACA,MAAM,YAA6E;EACjF,OAAO;GACL,QAAQ;GACR,GAAG;EACL;CACF;CACA,KAAK,YAA0E;EAC7E,OAAO;GACL,QAAQ;GACR,GAAG;EACL;CACF;CACA,SAAS,YAA6E;EACpF,OAAO;GACL,QAAQ;GACR,GAAG;EACL;CACF;AACF"}

package/esm/storage/context/storage-driver-context.d.mts

@@ -0,0 +1,72 @@
+import { StorageDriverContract } from "../types.mjs";
+import { Context } from "@warlock.js/context";
+
+//#region ../../@warlock.js/core/src/storage/context/storage-driver-context.d.ts
+type StorageDriverContextStore = {
+  driver?: StorageDriverContract;
+  prefix?: string;
+  metadata?: Record<string, any>;
+};
+/**
+ * Storage Driver Context
+ *
+ * Manages the active storage driver and path prefix using AsyncLocalStorage.
+ * Allows multi-tenant applications to switch drivers and isolate storage paths per request context.
+ *
+ * @example
+ * ```typescript
+ * // Set driver with tenant-specific prefix
+ * storageDriverContext.setDriver(storage.getDriver("s3"), {
+ *   prefix: "tenant-123",
+ *   metadata: { tenantId: "123" }
+ * });
+ *
+ * // Or just set prefix for same driver
+ * storageDriverContext.setPrefix("tenant-456");
+ * ```
+ */
+declare class StorageDriverContext extends Context<StorageDriverContextStore> {
+  /**
+   * Get the current storage driver
+   */
+  getDriver(): StorageDriverContract | undefined;
+  /**
+   * Get the current path prefix (e.g., tenant-specific path)
+   */
+  getPrefix(): string | undefined;
+  /**
+   * Get context metadata (e.g., tenantId)
+   */
+  getMetadata(): Record<string, any> | undefined;
+  /**
+   * Set the active driver with optional prefix and metadata
+   *
+   * @param driver - Storage driver to use
+   * @param options - Optional prefix and metadata
+   */
+  setDriver(driver: StorageDriverContract, options?: {
+    prefix?: string;
+    metadata?: Record<string, any>;
+  }): void;
+  /**
+   * Set only the path prefix (keeps current driver)
+   *
+   * Useful for multi-tenant scenarios where you want to isolate
+   * storage paths without changing the driver.
+   *
+   * @param prefix - Path prefix to prepend to all operations
+   */
+  setPrefix(prefix: string): void;
+  /**
+   * Clear the prefix
+   */
+  clearPrefix(): void;
+  /**
+   * Build the initial storage store with defaults
+   */
+  buildStore(): StorageDriverContextStore;
+}
+declare const storageDriverContext: StorageDriverContext;
+//#endregion
+export { StorageDriverContextStore, storageDriverContext };
+//# sourceMappingURL=storage-driver-context.d.mts.map

package/esm/storage/context/storage-driver-context.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage-driver-context.d.mts","names":[],"sources":["../../../../../../../@warlock.js/core/src/storage/context/storage-driver-context.ts"],"mappings":";;;;KAGY,yBAAA;EACV,MAAA,GAAS,qBAAA;EACT,MAAA;EACA,QAAA,GAAW,MAAM;AAAA;;;;;;;;AAAA;AACjB;;;;;;;;;;cAoBI,oBAAA,SAA6B,OAAA,CAAQ,yBAAA;EAAD;;;EAIjC,SAAA,CAAA,GAAa,qBAAA;EAAA;;;EAOb,SAAA,CAAA;EAiBA;;;EAVA,WAAA,CAAA,GAAe,MAAA;EAYS;;;;;;EAFxB,SAAA,CACL,MAAA,EAAQ,qBAAA,EACR,OAAA;IAAY,MAAA;IAAiB,QAAA,GAAW,MAAA;EAAA;EAwC/B;;;;AAAiD;;;;EAvBrD,SAAA,CAAU,MAAA;;;;EAOV,WAAA,CAAA;;;;EAOA,UAAA,CAAA,GAAc,yBAAA;AAAA;AAAA,cASV,oBAAA,EAAoB,oBAA6B"}

package/esm/storage/context/storage-driver-context.mjs

@@ -0,0 +1,87 @@
+import { Context, contextManager } from "@warlock.js/context";
+
+//#region ../../@warlock.js/core/src/storage/context/storage-driver-context.ts
+/**
+* Storage Driver Context
+*
+* Manages the active storage driver and path prefix using AsyncLocalStorage.
+* Allows multi-tenant applications to switch drivers and isolate storage paths per request context.
+*
+* @example
+* ```typescript
+* // Set driver with tenant-specific prefix
+* storageDriverContext.setDriver(storage.getDriver("s3"), {
+*   prefix: "tenant-123",
+*   metadata: { tenantId: "123" }
+* });
+*
+* // Or just set prefix for same driver
+* storageDriverContext.setPrefix("tenant-456");
+* ```
+*/
+var StorageDriverContext = class extends Context {
+	/**
+	* Get the current storage driver
+	*/
+	getDriver() {
+		return this.get("driver");
+	}
+	/**
+	* Get the current path prefix (e.g., tenant-specific path)
+	*/
+	getPrefix() {
+		return this.get("prefix");
+	}
+	/**
+	* Get context metadata (e.g., tenantId)
+	*/
+	getMetadata() {
+		return this.get("metadata");
+	}
+	/**
+	* Set the active driver with optional prefix and metadata
+	*
+	* @param driver - Storage driver to use
+	* @param options - Optional prefix and metadata
+	*/
+	setDriver(driver, options) {
+		this.update({
+			driver,
+			prefix: options?.prefix,
+			metadata: options?.metadata
+		});
+	}
+	/**
+	* Set only the path prefix (keeps current driver)
+	*
+	* Useful for multi-tenant scenarios where you want to isolate
+	* storage paths without changing the driver.
+	*
+	* @param prefix - Path prefix to prepend to all operations
+	*/
+	setPrefix(prefix) {
+		this.update({ prefix });
+	}
+	/**
+	* Clear the prefix
+	*/
+	clearPrefix() {
+		this.update({ prefix: void 0 });
+	}
+	/**
+	* Build the initial storage store with defaults
+	*/
+	buildStore() {
+		return {
+			driver: void 0,
+			prefix: void 0,
+			metadata: void 0
+		};
+	}
+};
+const storageDriverContext = new StorageDriverContext();
+contextManager.register("storage", storageDriverContext);
+
+//#endregion
+export { storageDriverContext };
+//# sourceMappingURL=storage-driver-context.mjs.map

package/esm/storage/context/storage-driver-context.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage-driver-context.mjs","names":[],"sources":["../../../../../../../@warlock.js/core/src/storage/context/storage-driver-context.ts"],"sourcesContent":["import { Context, contextManager } from \"@warlock.js/context\";\nimport type { StorageDriverContract } from \"../types\";\n\nexport type StorageDriverContextStore = {\n  driver?: StorageDriverContract;\n  prefix?: string;\n  metadata?: Record<string, any>;\n};\n\n/**\n * Storage Driver Context\n *\n * Manages the active storage driver and path prefix using AsyncLocalStorage.\n * Allows multi-tenant applications to switch drivers and isolate storage paths per request context.\n *\n * @example\n * ```typescript\n * // Set driver with tenant-specific prefix\n * storageDriverContext.setDriver(storage.getDriver(\"s3\"), {\n *   prefix: \"tenant-123\",\n *   metadata: { tenantId: \"123\" }\n * });\n *\n * // Or just set prefix for same driver\n * storageDriverContext.setPrefix(\"tenant-456\");\n * ```\n */\nclass StorageDriverContext extends Context<StorageDriverContextStore> {\n  /**\n   * Get the current storage driver\n   */\n  public getDriver(): StorageDriverContract | undefined {\n    return this.get(\"driver\");\n  }\n\n  /**\n   * Get the current path prefix (e.g., tenant-specific path)\n   */\n  public getPrefix(): string | undefined {\n    return this.get(\"prefix\");\n  }\n\n  /**\n   * Get context metadata (e.g., tenantId)\n   */\n  public getMetadata(): Record<string, any> | undefined {\n    return this.get(\"metadata\");\n  }\n\n  /**\n   * Set the active driver with optional prefix and metadata\n   *\n   * @param driver - Storage driver to use\n   * @param options - Optional prefix and metadata\n   */\n  public setDriver(\n    driver: StorageDriverContract,\n    options?: { prefix?: string; metadata?: Record<string, any> },\n  ): void {\n    this.update({\n      driver,\n      prefix: options?.prefix,\n      metadata: options?.metadata,\n    });\n  }\n\n  /**\n   * Set only the path prefix (keeps current driver)\n   *\n   * Useful for multi-tenant scenarios where you want to isolate\n   * storage paths without changing the driver.\n   *\n   * @param prefix - Path prefix to prepend to all operations\n   */\n  public setPrefix(prefix: string): void {\n    this.update({ prefix });\n  }\n\n  /**\n   * Clear the prefix\n   */\n  public clearPrefix(): void {\n    this.update({ prefix: undefined });\n  }\n\n  /**\n   * Build the initial storage store with defaults\n   */\n  public buildStore(): StorageDriverContextStore {\n    return {\n      driver: undefined,\n      prefix: undefined,\n      metadata: undefined,\n    };\n  }\n}\n\nexport const storageDriverContext = new StorageDriverContext();\n\ncontextManager.register(\"storage\", storageDriverContext);\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AA2BA,IAAM,uBAAN,cAAmC,QAAmC;;;;CAIpE,AAAO,YAA+C;EACpD,OAAO,KAAK,IAAI,QAAQ;CAC1B;;;;CAKA,AAAO,YAAgC;EACrC,OAAO,KAAK,IAAI,QAAQ;CAC1B;;;;CAKA,AAAO,cAA+C;EACpD,OAAO,KAAK,IAAI,UAAU;CAC5B;;;;;;;CAQA,AAAO,UACL,QACA,SACM;EACN,KAAK,OAAO;GACV;GACA,QAAQ,SAAS;GACjB,UAAU,SAAS;EACrB,CAAC;CACH;;;;;;;;;CAUA,AAAO,UAAU,QAAsB;EACrC,KAAK,OAAO,EAAE,OAAO,CAAC;CACxB;;;;CAKA,AAAO,cAAoB;EACzB,KAAK,OAAO,EAAE,QAAQ,OAAU,CAAC;CACnC;;;;CAKA,AAAO,aAAwC;EAC7C,OAAO;GACL,QAAQ;GACR,QAAQ;GACR,UAAU;EACZ;CACF;AACF;AAEA,MAAa,uBAAuB,IAAI,qBAAqB;AAE7D,eAAe,SAAS,WAAW,oBAAoB"}