kuwan-expresspack-core 0.1.16 → 0.1.17

package/dist/chunk-55RBYZEZ.mjs

@@ -0,0 +1,5 @@
+import { AsyncLocalStorage } from 'async_hooks';
+
+var a=new AsyncLocalStorage;function n(e){return {get(t){return e.data.get(t)},set(t,o){e.data.set(t,o);},has(t){return e.data.has(t)},delete(t){return e.data.delete(t)},clear(){e.data.clear();}}}function c(){let e=a.getStore();if(!e)throw new Error("No context available. Ensure context middleware is registered before accessing context.");return n(e)}function i(){let e=a.getStore();return e?n(e):void 0}function y(e){let t={data:new Map};return a.run(t,e)}
+
+export { a, n as b, c, i as d, y as e };

package/dist/chunk-FFCH7NYQ.mjs

@@ -0,0 +1,3 @@
+function r(e){let n=(t,o)=>{e.appContext||(e.appContext={}),e.appContext[t]=o;};function a(t){return e.appContext?.[t]}return {set:n,get:a}}
+
+export { r as a };

package/dist/context/context-store/context-store-internal.d.ts

@@ -0,0 +1,140 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+
+/**
+ * Application context with typed access methods
+ */
+interface AppContext<TData extends Record<string, any> = Record<string, any>> {
+    /**
+     * Get a value from the context store
+     *
+     * @param key - The key to retrieve
+     * @returns The stored value or undefined
+     *
+     * @example
+     * ```typescript
+     * interface MyContext {
+     *     user: { id: number; name: string };
+     *     tenantId: string;
+     * }
+     *
+     * const ctx = getAppContext<MyContext>();
+     * const user = ctx.get('user'); // type is { id: number; name: string } | undefined
+     * ```
+     */
+    get<K extends keyof TData>(key: K): TData[K] | undefined;
+    /**
+     * Set a value in the context store
+     *
+     * @param key - The key to store the value under
+     * @param value - The value to store
+     *
+     * @example
+     * ```typescript
+     * const ctx = getAppContext<MyContext>();
+     * ctx.set('user', { id: 1, name: 'John' }); // fully typed
+     * ```
+     */
+    set<K extends keyof TData>(key: K, value: TData[K]): void;
+    /**
+     * Check if a key exists in the context store
+     *
+     * @param key - The key to check
+     * @returns True if the key exists
+     */
+    has<K extends keyof TData>(key: K): boolean;
+    /**
+     * Delete a value from the context store
+     *
+     * @param key - The key to delete
+     * @returns True if the key existed and was deleted
+     */
+    delete<K extends keyof TData>(key: K): boolean;
+    /**
+     * Clear all values from the context store
+     */
+    clear(): void;
+}
+/**
+ * Internal context structure
+ */
+interface InternalContext<TData extends Record<string, any> = Record<string, any>> {
+    data: Map<keyof TData, any>;
+}
+/**
+ * AsyncLocalStorage instance for managing context
+ */
+declare const asyncLocalStorage: AsyncLocalStorage<InternalContext<any>>;
+/**
+ * Create a typed context proxy from internal context
+ */
+declare function createContextProxy<TData extends Record<string, any>>(internal: InternalContext<TData>): AppContext<TData>;
+/**
+ * Get the current application context with custom type support
+ *
+ * @throws {Error} If called outside of context
+ * @returns {AppContext<TData>} The current context
+ *
+ * @example
+ * ```typescript
+ * import { getAppContext } from 'expresspack';
+ *
+ * interface MyContext {
+ *     user: { id: number; name: string };
+ *     tenantId: string;
+ * }
+ *
+ * export function someHandler(req, res) {
+ *     const ctx = getAppContext<MyContext>();
+ *
+ *     // Fully typed access
+ *     const user = ctx.get('user'); // type: { id: number; name: string } | undefined
+ *
+ *     // Fully typed set
+ *     ctx.set('user', { id: 1, name: 'John' });
+ * }
+ * ```
+ */
+declare function getAppContext<TData extends Record<string, any> = Record<string, any>>(): AppContext<TData>;
+/**
+ * Get the current application context, returns undefined if not available
+ * Useful for optional context access
+ *
+ * @returns {AppContext<TData> | undefined} The current context or undefined
+ *
+ * @example
+ * ```typescript
+ * import { tryGetAppContext } from 'expresspack';
+ *
+ * export function someUtility() {
+ *     const ctx = tryGetAppContext<MyContext>();
+ *     if (ctx) {
+ *         const user = ctx.get('user');
+ *     }
+ * }
+ * ```
+ */
+declare function tryGetAppContext<TData extends Record<string, any> = Record<string, any>>(): AppContext<TData> | undefined;
+/**
+ * Run a function within a context (useful for testing)
+ *
+ * @param fn - The function to execute
+ * @returns The result of the function
+ *
+ * @example
+ * ```typescript
+ * import { runInContext } from 'expresspack';
+ *
+ * interface MyContext {
+ *     userId: number;
+ * }
+ *
+ * const result = runInContext(() => {
+ *     const ctx = getAppContext<MyContext>();
+ *     ctx.set('userId', 123);
+ *     return someFunction();
+ * });
+ * ```
+ */
+declare function runInContext<T>(fn: () => T): T;
+
+export { type AppContext, type InternalContext, asyncLocalStorage, createContextProxy, getAppContext, runInContext, tryGetAppContext };

package/dist/context/context-store/context-store-internal.mjs

@@ -0,0 +1 @@
+export { a as asyncLocalStorage, b as createContextProxy, c as getAppContext, e as runInContext, d as tryGetAppContext } from '../../chunk-55RBYZEZ.mjs';

package/dist/context/context-store/index.d.ts

@@ -0,0 +1,2 @@
+export { getAppContext, tryGetAppContext } from './context-store-internal.js';
+import 'node:async_hooks';

package/dist/context/context-store/index.mjs

@@ -0,0 +1 @@
+export { c as getAppContext, d as tryGetAppContext } from '../../chunk-55RBYZEZ.mjs';

package/dist/context/index.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/context/index.mjs

@@ -0,0 +1 @@
+

package/dist/context/simple-context.d.ts

@@ -0,0 +1,16 @@
+import { Request } from 'express';
+
+/**
+ * Simple Context - Use when AsyncLocalStorage is not needed or not available.
+ *
+ */
+
+/**
+ * Helper function to set/get values in Request.
+ */
+declare function useAppContext<TData extends Record<never, never> = Record<never, never>>(req: Request): {
+    set: (key: string, value: any) => void;
+    get: <K extends keyof TData>(key: K) => TData[K] | undefined;
+};
+
+export { useAppContext };

package/dist/context/simple-context.mjs

@@ -0,0 +1 @@
+export { a as useAppContext } from '../chunk-FFCH7NYQ.mjs';

package/dist/index.mjs

@@ -1,5 +1,5 @@
-import { a as a$1 } from './chunk-JKH5TYED.mjs';
 import { e } from './chunk-OXUMMLIO.mjs';
+import { a as a$1 } from './chunk-JKH5TYED.mjs';
 import { a as a$2 } from './chunk-VSPZT4K6.mjs';
 import { a, f } from './chunk-CZGPAGDK.mjs';
 import { Router } from 'express';

package/dist/middlewares/app-context/index.d.ts

@@ -0,0 +1,48 @@
+import { Request, Response, NextFunction } from 'express';
+
+/**
+ * Configuration options for context middleware
+ */
+interface ContextStoreConfig {
+    /**
+     * Whether to enable the context middleware
+     * @default true
+     */
+    enabled?: boolean;
+}
+/**
+ * Express middleware that initializes async context for each request
+ * This middleware must be registered before any code that uses getAppContext()
+ *
+ * @example
+ * ```typescript
+ * import express from 'express';
+ * import { contextStoreMiddleware } from 'expresspack';
+ *
+ * const app = express();
+ *
+ * // Register as early as possible
+ * app.use(contextStoreMiddleware());
+ * ```
+ */
+declare function contextStoreMiddleware(): (req: Request, res: Response, next: NextFunction) => void;
+/**
+ * For types you need to augment the Request type to include appContext
+ * and also include the type for appContext.
+ *
+ * @example
+ * ```ts
+ * declare global {
+ *  namespace Express {
+ *   interface Request {
+ *      appContext: {
+ *          user: User;
+ *          session: Session;
+ *      };
+ *   }
+ * }
+ * ```
+ */
+declare function simpleContextMiddleware(): (req: Request, res: Response, next: NextFunction) => void;
+
+export { type ContextStoreConfig, contextStoreMiddleware, simpleContextMiddleware };

package/dist/middlewares/app-context/index.mjs

@@ -0,0 +1,6 @@
+import { a } from '../../chunk-55RBYZEZ.mjs';
+import { a as a$1 } from '../../chunk-FFCH7NYQ.mjs';
+
+function u(){return (e,p,t)=>{let n={data:new Map};a.run(n,()=>{t();});}}function c(){return (e,p,t)=>{let n=a$1(e);e.appContext=n,t();}}
+
+export { u as contextStoreMiddleware, c as simpleContextMiddleware };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kuwan-expresspack-core",
-  "version": "0.1.16",
+  "version": "0.1.17",
   "description": "",
   "type": "module",
   "main": "./dist/index.mjs",
@@ -57,6 +57,18 @@
       "types": "./dist/middlewares/error-handler/index.d.ts",
       "import": "./dist/middlewares/error-handler/index.mjs"
     },
+    "./middlewares/app-context": {
+      "types": "./dist/middlewares/app-context/index.d.ts",
+      "import": "./dist/middlewares/app-context/index.mjs"
+    },
+    "./context-store": {
+      "types": "./dist/context/context-store/index.d.ts",
+      "import": "./dist/context/context-store/index.mjs"
+    },
+    "./simple-context": {
+      "types": "./dist/context/simple-context.d.ts",
+      "import": "./dist/context/simple-context.mjs"
+    },
     "./services/*": {
       "types": "./dist/services/*/index.d.ts",
       "import": "./dist/services/*/index.mjs"