@cldmv/slothlet 2.8.0 → 2.10.0

package/dist/lib/helpers/api_builder/metadata.mjs

@@ -0,0 +1,248 @@
+/*
+	Copyright 2026 CLDMV/Shinrai
+
+	Licensed under the Apache License, Version 2.0 (the "License");
+	you may not use this file except in compliance with the License.
+	You may obtain a copy of the License at
+
+		http://www.apache.org/licenses/LICENSE-2.0
+
+	Unless required by applicable law or agreed to in writing, software
+	distributed under the License is distributed on an "AS IS" BASIS,
+	WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+	See the License for the specific language governing permissions and
+	limitations under the License.
+*/
+
+
+
+
+
+
+export function createImmutableMetadata(initial = {}) {
+	
+	
+	
+	function makeImmutable(obj, visited = new WeakSet()) {
+		if (obj === null || typeof obj !== "object") return obj;
+		if (visited.has(obj)) return obj;
+		visited.add(obj);
+
+		
+		if (Array.isArray(obj)) {
+			
+			for (let i = 0; i < obj.length; i++) {
+				obj[i] = makeImmutable(obj[i], visited);
+			}
+
+			
+			
+			return new Proxy(obj, {
+				set() {
+					
+					
+					return false;
+				},
+				deleteProperty() {
+					
+					return false;
+				}
+			});
+		}
+
+		
+		for (const [key, value] of Object.entries(obj)) {
+			const immutableValue = makeImmutable(value, visited);
+			Object.defineProperty(obj, key, {
+				value: immutableValue,
+				writable: false, 
+				enumerable: true,
+				configurable: true
+			});
+		}
+
+		
+		return new Proxy(obj, {
+			set(target, prop, value) {
+				const descriptor = Object.getOwnPropertyDescriptor(target, prop);
+
+				
+				if (descriptor && !descriptor.writable) {
+					return false;
+				}
+
+				
+				if (!descriptor) {
+					const immutableValue = makeImmutable(value);
+					Object.defineProperty(target, prop, {
+						value: immutableValue,
+						writable: false,
+						enumerable: true,
+						configurable: true
+					});
+					return true;
+				}
+
+				return Reflect.set(target, prop, value);
+			},
+			deleteProperty() {
+				
+				return false;
+			}
+		});
+	}
+
+	
+	const base = {};
+
+	
+	
+	for (const [key, value] of Object.entries(initial)) {
+		const immutableValue = makeImmutable(value);
+		Object.defineProperty(base, key, {
+			value: immutableValue,
+			writable: false,
+			enumerable: true,
+			configurable: true 
+		});
+	}
+
+	
+	return new Proxy(base, {
+		set(target, prop, value) {
+			
+			const descriptor = Object.getOwnPropertyDescriptor(target, prop);
+
+			
+			if (descriptor && !descriptor.writable) {
+				if (process.env.SLOTHLET_DEBUG) {
+					console.warn(`[slothlet] Cannot modify existing metadata property: "${String(prop)}"`);
+				}
+				
+				
+				return false;
+			}
+
+			
+			if (!descriptor) {
+				Object.defineProperty(target, prop, {
+					value,
+					writable: false,
+					enumerable: true,
+					configurable: true 
+				});
+				return true;
+			}
+
+			
+			
+			return Reflect.set(target, prop, value);
+		},
+
+		deleteProperty(target, prop) {
+			
+			if (process.env.SLOTHLET_DEBUG) {
+				console.warn(`[slothlet] Cannot delete metadata property: "${String(prop)}"`);
+			}
+			return true; 
+		}
+	});
+}
+
+
+export function cleanMetadata(obj, visited = new WeakSet()) {
+	
+	if (!obj || (typeof obj !== "object" && typeof obj !== "function")) return;
+	if (visited.has(obj)) return;
+	visited.add(obj);
+
+	
+	if (typeof obj === "function") {
+		try {
+			if (obj.__metadata) {
+				delete obj.__metadata;
+			}
+			if (obj.__sourceFolder) {
+				delete obj.__sourceFolder;
+			}
+		} catch (_) {
+			
+		}
+	}
+
+	
+	try {
+		const keys = Object.keys(obj);
+		for (const key of keys) {
+			if (
+				key.startsWith("_") ||
+				["hooks", "shutdown", "addApi", "describe", "run", "__proto__", "constructor", "prototype"].includes(key)
+			) {
+				continue;
+			}
+			cleanMetadata(obj[key], visited);
+		}
+	} catch {
+		
+	}
+}
+
+
+export function tagLoadedFunctions(obj, metadata, baseDir, visited = new WeakSet()) {
+	
+	if (!obj || (typeof obj !== "object" && typeof obj !== "function")) return;
+	if (visited.has(obj)) return;
+	visited.add(obj);
+
+	
+	if (typeof obj === "function") {
+		try {
+			
+			const immutableMeta = createImmutableMetadata(metadata);
+
+			Object.defineProperty(obj, "__metadata", {
+				value: immutableMeta,
+				writable: false,
+				enumerable: false,
+				configurable: true 
+			});
+
+			
+			if (metadata.sourceFolder) {
+				Object.defineProperty(obj, "__sourceFolder", {
+					value: metadata.sourceFolder,
+					writable: false,
+					enumerable: false,
+					configurable: true 
+				});
+			}
+
+			
+			
+			
+		} catch (error) {
+			
+			if (metadata.debug) {
+				console.warn(`[slothlet] Could not tag function with metadata:`, error.message);
+			}
+		}
+	}
+
+	
+	try {
+		const keys = Object.keys(obj);
+		for (const key of keys) {
+			
+			if (
+				key.startsWith("_") ||
+				["hooks", "shutdown", "addApi", "describe", "run", "__proto__", "constructor", "prototype"].includes(key)
+			) {
+				continue;
+			}
+
+			tagLoadedFunctions(obj[key], metadata, baseDir, visited);
+		}
+	} catch {
+		
+	}
+}