@cldmv/slothlet 2.11.0 → 3.0.1

package/dist/lib/runtime/runtime-asynclocalstorage.mjs

@@ -14,558 +14,116 @@
 	limitations under the License.
 */
 
-
 
 
 
-import { AsyncLocalStorage } from "node:async_hooks";
-import util from "node:util";
-import { enableAlsForEventEmitters } from "@cldmv/slothlet/helpers/als-eventemitter";
-import { metadataAPI } from "@cldmv/slothlet/helpers/metadata-api";
 
-const als = new AsyncLocalStorage();
+import { asyncRuntime } from "@cldmv/slothlet/factories/context";
+import { SlothletError } from "@cldmv/slothlet/errors";
 
 
-export const sharedALS = new AsyncLocalStorage();
-
-
-export const requestALS = new AsyncLocalStorage();
-
-
-enableAlsForEventEmitters(als);
-
-
-export const runWithCtx = (ctx, fn, thisArg, args) => {
-	
-	if (!ctx.hookManager?.enabled || !fn.__slothletPath) {
-		const runtime_runInALS = () => {
-			const result = Reflect.apply(fn, thisArg, args);
-			return result;
-		};
-		return als.run(ctx, runtime_runInALS);
-	}
-
-	
-	const requestContext = requestALS.getStore();
-	const mergedCtx = requestContext ? { ...ctx, context: { ...ctx.context, ...requestContext } } : ctx;
-
-	
-	const path = fn.__slothletPath;
-
-	
-	const runtime_runInALS = () => {
-		try {
-			
-			const beforeResult = mergedCtx.hookManager.executeBeforeHooks(path, args);
-
-			
-			if (beforeResult.cancelled) {
-				mergedCtx.hookManager.executeAlwaysHooks(path, beforeResult.value, []);
-				return beforeResult.value;
-			}
-
-			
-			const actualArgs = beforeResult.args;
-
-			
-			const result = Reflect.apply(fn, thisArg, actualArgs);
-
-			
-			if (result && typeof result === "object" && typeof result.then === "function") {
-				return result.then(
-					(resolvedResult) => {
-						
-						const finalResult = mergedCtx.hookManager.executeAfterHooks(path, resolvedResult);
-						mergedCtx.hookManager.executeAlwaysHooks(path, finalResult, []);
-						return finalResult;
-					},
-					(error) => {
-						
-						if (!mergedCtx.hookManager.reportedErrors.has(error)) {
-							mergedCtx.hookManager.reportedErrors.add(error);
-							mergedCtx.hookManager.executeErrorHooks(path, error, { type: "function" });
-						}
-						
-						mergedCtx.hookManager.executeAlwaysHooks(path, undefined, [error]);
-						
-						if (!mergedCtx.hookManager.suppressErrors) {
-							throw error;
-						}
-						return undefined; 
-					}
-				);
-			}
-
-			
-			const finalResult = mergedCtx.hookManager.executeAfterHooks(path, result);
-			mergedCtx.hookManager.executeAlwaysHooks(path, finalResult, []);
-			return finalResult;
-		} catch (error) {
-			
-			if (!mergedCtx.hookManager.reportedErrors.has(error)) {
-				mergedCtx.hookManager.reportedErrors.add(error);
-				mergedCtx.hookManager.executeErrorHooks(path, error, { type: "function" });
-			}
-			
-			mergedCtx.hookManager.executeAlwaysHooks(path, undefined, [error]);
-			
-			if (!mergedCtx.hookManager.suppressErrors) {
-				throw error;
-			}
-			return undefined; 
-		}
-	};
-
-	return als.run(mergedCtx, runtime_runInALS);
-};
-
-
-export const getCtx = () => als.getStore() || null;
-
-
-const EXCLUDED_CONSTRUCTORS = new Set([Object, Array, Promise, Date, RegExp, Error]);
-
-
-const EXCLUDED_INSTANCEOF_CLASSES = [ArrayBuffer, Map, Set, WeakMap, WeakSet];
-
-
-const PROMISE_METHODS = new Set(["then", "catch", "finally"]);
-
-
-function runtime_shouldWrapMethod(value, prop) {
-	return (
-		typeof value === "function" &&
-		typeof prop === "string" && 
-		prop !== "constructor" &&
-		!(prop in Object.prototype) &&
-		!prop.startsWith("__")
-	);
-}
-
-
-function runtime_shouldExcludeFromProxy(val) {
-	if (val == null || typeof val !== "object") {
-		return false;
-	}
-
-	
-	
-	for (const cls of EXCLUDED_INSTANCEOF_CLASSES) {
-		if (typeof cls === "function" && val instanceof cls) {
-			return true;
-		}
-	}
-
-	return false;
-}
-
-
-function runtime_isClassInstance(val) {
-	if (
-		val == null ||
-		typeof val !== "object" ||
-		!val.constructor ||
-		typeof val.constructor !== "function" ||
-		EXCLUDED_CONSTRUCTORS.has(val.constructor)
-	) {
-		return false;
-	}
-
-	for (const cls of EXCLUDED_INSTANCEOF_CLASSES) {
-		if (typeof cls === "function" && val instanceof cls) {
-			return false;
-		}
+function safeGetContext() {
+	try {
+		return asyncRuntime.getContext();
+	} catch {
+		return null;
 	}
-
-	return true;
 }
 
 
-function runtime_wrapClassInstance(instance, ctx, wrapFn, instanceCache) {
-	if (instanceCache.has(instance)) {
-		return instanceCache.get(instance);
-	}
-
-	
-	const methodCache = new Map();
-
-	const wrappedInstance = new Proxy(instance, {
-		get(target, prop, receiver) {
-			
-			if (methodCache.has(prop)) {
-				return methodCache.get(prop);
-			}
-
-			const value = Reflect.get(target, prop, receiver);
-
-			
-			
-			if (runtime_shouldWrapMethod(value, prop)) {
-				
-				
-				const runtime_contextPreservingMethod = function (...args) {
-					const result = runWithCtx(ctx, value, target, args);
-					
-					return wrapFn(result);
-				};
-
-				
-				methodCache.set(prop, runtime_contextPreservingMethod);
-				return runtime_contextPreservingMethod;
+export const self = new Proxy(
+	{},
+	{
+		get(_, prop) {
+			const ctx = safeGetContext();
+			if (!ctx || !ctx.self) {
+				throw new SlothletError("RUNTIME_NO_ACTIVE_CONTEXT_SELF", {}, null, { validationError: true });
 			}
-
-			
-			return wrapFn(value);
+			return ctx.self[prop];
 		},
-
-		set(target, prop, value, receiver) {
+		ownKeys() {
+			const ctx = safeGetContext();
+			if (!ctx || !ctx.self) return [];
+			return Reflect.ownKeys(ctx.self);
+		},
+		has(_, prop) {
+			const ctx = safeGetContext();
+			if (!ctx || !ctx.self) return false;
+			return prop in ctx.self;
+		},
+		getOwnPropertyDescriptor(_, prop) {
+			const ctx = safeGetContext();
+			if (!ctx || !ctx.self) return undefined;
+			const desc = Reflect.getOwnPropertyDescriptor(ctx.self, prop);
+			
 			
-			if (methodCache.has(prop)) {
-				methodCache.delete(prop);
+			if (desc) {
+				return { ...desc, configurable: true };
 			}
-			return Reflect.set(target, prop, value, receiver);
-		}
-	});
-
-	instanceCache.set(instance, wrappedInstance);
-	return wrappedInstance;
-}
-
-
-export const makeWrapper = (ctx) => {
-	const cache = new WeakMap();
-	const instanceCache = new WeakMap();
-	const promiseMethodCache = new WeakMap(); 
-	const wrap = (val, currentPath = "") => {
-		if (val == null || (typeof val !== "object" && typeof val !== "function")) return val;
-		if (cache.has(val)) return cache.get(val);
-
-		
-		
-		if (runtime_shouldExcludeFromProxy(val)) {
-			cache.set(val, val); 
-			return val;
+			return undefined;
 		}
-
-		const proxied = new Proxy(val, {
-			apply(target, thisArg, args) {
-				const result = runWithCtx(ctx, target, thisArg, args);
-
-				
-				if (runtime_isClassInstance(result)) {
-					return runtime_wrapClassInstance(result, ctx, wrap, instanceCache);
-				}
-
-				return result;
-			},
-			construct(target, args, newTarget) {
-				
-				const result = runWithCtx(ctx, Reflect.construct, undefined, [target, args, newTarget]);
-
-				
-				if (runtime_isClassInstance(result)) {
-					return runtime_wrapClassInstance(result, ctx, wrap, instanceCache);
-				}
-
-				return result;
-			},
-			get(target, prop, receiver) {
-				const value = Reflect.get(target, prop, receiver);
-
-				
-				const newPath = currentPath ? `${currentPath}.${String(prop)}` : String(prop);
-
-				
-				const isInternalProperty = currentPath === "" && ["hooks", "__ctx", "shutdown", "_impl"].includes(String(prop));
-				const isInternalPath = newPath.startsWith("hooks.") || newPath.startsWith("__ctx.") || newPath.startsWith("shutdown.");
-
-				
-				if (typeof value === "function" && !value.__slothletPath && !isInternalProperty && !isInternalPath) {
-					try {
-						Object.defineProperty(value, "__slothletPath", {
-							value: newPath,
-							writable: false,
-							enumerable: false,
-							configurable: true
-						});
-					} catch {
-						
-					}
-				}
-
-				
-				
-				const isPromiseMethod = typeof value === "function" && PROMISE_METHODS.has(prop);
-				const isNativePromise = util.types.isPromise(target);
-				const hasThen = typeof target?.then === "function";
-
-				if (isPromiseMethod && (isNativePromise || hasThen)) {
-					
-					let targetMethodCache = promiseMethodCache.get(target);
-					if (!targetMethodCache) {
-						targetMethodCache = new Map();
-						promiseMethodCache.set(target, targetMethodCache);
-					}
-
-					if (targetMethodCache.has(prop)) {
-						return targetMethodCache.get(prop);
-					}
-
-					const wrappedMethod = function (...args) {
-						
-						const wrappedArgs = args.map((arg) => {
-							if (typeof arg === "function") {
-								return function (...callbackArgs) {
-									return runWithCtx(ctx, arg, undefined, callbackArgs);
-								};
-							}
-							return arg;
-						});
-
-						
-						const result = Reflect.apply(value, target, wrappedArgs);
-						
-						return wrap(result, newPath);
-					};
-
-					targetMethodCache.set(prop, wrappedMethod);
-					return wrappedMethod;
-				}
-
-				return wrap(value, newPath);
-			},
-			set(target, prop, value, receiver) {
-				
-				const methodCache = promiseMethodCache.get(target);
-				if (methodCache && methodCache.has(prop)) {
-					methodCache.delete(prop);
-				}
-				return Reflect.set(target, prop, value, receiver);
-			},
-			defineProperty: Reflect.defineProperty,
-			deleteProperty(target, prop) {
-				
-				const methodCache = promiseMethodCache.get(target);
-				if (methodCache && methodCache.has(prop)) {
-					methodCache.delete(prop);
-				}
-				return Reflect.deleteProperty(target, prop);
-			},
-			ownKeys: Reflect.ownKeys,
-			getOwnPropertyDescriptor: Reflect.getOwnPropertyDescriptor,
-			has: Reflect.has
-		});
-
-		cache.set(val, proxied);
-		return proxied;
-	};
-	return wrap;
-};
-
-function runtime_mutateLiveBinding(target, contextKey) {
-	const ctx = getCtx();
-	const source = ctx?.[contextKey];
-
-	
-	if (!source) {
-		for (const key of Object.keys(target)) {
-			if (key !== "_impl") delete target[key];
-		}
-		return;
 	}
+);
 
-	if (typeof source === "function") {
-		
-		
-		const runtime_forwardToSource = (...args) => source(...args);
-		target._impl = runtime_forwardToSource;
 
-		
-		for (const key of Object.keys(target)) {
-			if (key !== "_impl") delete target[key];
-		}
-		for (const key of Object.getOwnPropertyNames(source)) {
-			if (key !== "length" && key !== "name" && key !== "prototype" && key !== "_impl") {
-				try {
-					target[key] = source[key];
-				} catch {
-					
-				}
+export const context = new Proxy(
+	{},
+	{
+		get(_, prop) {
+			const ctx = safeGetContext();
+			if (!ctx || !ctx.context) {
+				return undefined;
 			}
-		}
-	} else if (typeof source === "object" && source !== null) {
-		
-		for (const key of Object.keys(target)) {
-			if (key !== "_impl") delete target[key];
-		}
-		for (const [key, value] of Object.entries(source)) {
-			try {
-				target[key] = value;
-			} catch (error) {
-				
-				
-				
-				if (error instanceof TypeError && error.message.includes("read only")) {
-					continue;
-				}
-				
-				throw error;
+			return ctx.context[prop];
+		},
+		set(_, prop, value) {
+			const ctx = safeGetContext();
+			if (!ctx || !ctx.context) {
+				throw new SlothletError("RUNTIME_NO_ACTIVE_CONTEXT_CONTEXT", {}, null, { validationError: true });
 			}
-		}
-		if (typeof source._impl === "function") {
-			target._impl = source._impl;
+			ctx.context[prop] = value;
+			return true;
+		},
+		ownKeys() {
+			const ctx = safeGetContext();
+			if (!ctx || !ctx.context) return [];
+			return Reflect.ownKeys(ctx.context);
+		},
+		has(_, prop) {
+			const ctx = safeGetContext();
+			if (!ctx || !ctx.context) return false;
+			return prop in ctx.context;
+		},
+		getOwnPropertyDescriptor(_, prop) {
+			const ctx = safeGetContext();
+			if (!ctx || !ctx.context) return undefined;
+			return Reflect.getOwnPropertyDescriptor(ctx.context, prop);
 		}
 	}
-}
-
-
-function runtime_createLiveBinding(contextKey) {
-	
-	
-	function runtime_liveBindingTarget() {}
-	const liveBinding = runtime_liveBindingTarget;
+);
 
-	
-	const runtime_syncWithContext = () => runtime_mutateLiveBinding(liveBinding, contextKey);
 
-	
-	
-	const runtime_renderSnapshot = (val) => {
-		if (typeof val === "function") {
-			const name = val.name || "anonymous";
-			const props = {};
-			for (const k of Object.keys(val)) props[k] = val[k];
-			
-			return { [`[Function: ${name}]`]: true, ...props };
-		}
-		return val;
-	};
 
-	const proxy = new Proxy(liveBinding, {
-		
-		apply(_t, thisArg, args) {
-			const cur = getCtx()?.[contextKey];
-			if (typeof cur === "function") {
-				return Reflect.apply(cur, thisArg, args);
-			}
-			
-			return cur;
-		},
-		construct(_t, args, newTarget) {
-			const cur = getCtx()?.[contextKey];
-			if (typeof cur === "function") {
-				return Reflect.construct(cur, args, newTarget);
-			}
-			throw new TypeError(`${contextKey} is not a constructor`);
-		},
 
-		get(target, prop) {
-			
-			if (prop === "nonExistentTestProperty") {
-				
-				
-				
+export const instanceID = new Proxy(
+	{},
+	{
+		get(_, prop) {
+			const ctx = safeGetContext();
+			if (!ctx || !ctx.instanceID) {
 				return undefined;
 			}
-
 			
-			if (prop === util.inspect.custom) return runtime_inspectHandler;
-			if (prop === "toJSON") return runtime_toJSONHandler;
-			if (prop === "$value") return runtime_toJSONHandler;
-			if (prop === Symbol.toPrimitive) {
-				
-				const runtime_toPrimitiveHandler = (hint) => {
-					const v = getCtx()?.[contextKey];
-					return hint === "string" ? String(v) : v;
-				};
-				return runtime_toPrimitiveHandler;
+			if (prop === Symbol.toPrimitive || prop === "toString" || prop === "valueOf") {
+				return () => ctx.instanceID;
 			}
-
-			
-			
-
-			
-			if (contextKey === "context") {
-				const ctx = getCtx();
-				const baseContext = ctx?.context || {};
-				const requestContext = requestALS.getStore() || {};
-
-				
-				
-				const isDeepMerge = ctx?.config?.scope?.merge === "deep";
-
-				if (isDeepMerge && Object.keys(requestContext).length > 0) {
-					
-					return requestContext[prop];
-				}
-
-				
-				const merged = { ...baseContext, ...requestContext };
-				return merged[prop];
-			}
-
-			
-			runtime_syncWithContext();
-			return target[prop];
+			return ctx.instanceID[prop];
 		},
-
-		set(target, prop, value) {
-			runtime_syncWithContext();
-			target[prop] = value;
-
+		has(_, prop) {
+			const ctx = safeGetContext();
+			if (!ctx || !ctx.instanceID) return false;
 			
-			const ctx = getCtx();
-			if (ctx && ctx[contextKey] && typeof ctx[contextKey] === "object") {
-				ctx[contextKey][prop] = value;
-			}
-			return true;
-		},
-
-		has(target, prop) {
-			runtime_syncWithContext();
-			return prop in target;
-		},
-
-		ownKeys(target) {
-			runtime_syncWithContext();
-			return Reflect.ownKeys(target);
-		},
-
-		getOwnPropertyDescriptor(target, prop) {
-			runtime_syncWithContext();
-			return Object.getOwnPropertyDescriptor(target, prop);
+			return prop in Object(ctx.instanceID);
 		}
-	});
-
-	
-	
-	const runtime_inspectHandler = () => runtime_renderSnapshot(getCtx()?.[contextKey]);
-
-	
-	const runtime_toJSONHandler = () => getCtx()?.[contextKey];
-
-	Object.defineProperty(liveBinding, util.inspect.custom, { value: runtime_inspectHandler, enumerable: false });
-	Object.defineProperty(liveBinding, "toJSON", { value: runtime_toJSONHandler, enumerable: false });
-
-	
-	
-	
-
-	return proxy;
-}
-
-
-
-
-export const self = runtime_createLiveBinding("self");
-
-
-export const context = runtime_createLiveBinding("context");
-
-
-export const reference = runtime_createLiveBinding("reference");
-
-
-export { metadataAPI };
-
-
+	}
+);