@cldmv/slothlet 2.7.1 → 2.9.0

package/dist/lib/helpers/als-eventemitter.mjs

@@ -18,9 +18,8 @@
 
 
 
-import { AsyncResource } from "node:async_hooks";
+import { AsyncResource, AsyncLocalStorage } from "node:async_hooks";
 import { EventEmitter } from "node:events";
-import { AsyncLocalStorage } from "node:async_hooks";
 
 
 const defaultALS = new AsyncLocalStorage();
@@ -151,7 +150,7 @@ export function enableAlsForEventEmitters(als = defaultALS) {
 				globalResourceSet.delete(resource);
 				try {
 					resource.emitDestroy();
-				} catch (err) {
+				} catch (_) {
 					
 				}
 			}
@@ -204,7 +203,7 @@ export function cleanupAllSlothletListeners() {
 				emitter.removeListener(event, wrappedListener);
 				cleanedCount++;
 			}
-		} catch (err) {
+		} catch (_) {
 			errorCount++;
 			
 		}
@@ -214,7 +213,7 @@ export function cleanupAllSlothletListeners() {
 	allPatchedListeners.clear();
 	
 
-	if (process.env.NODE_ENV === "development" || process.env.SLOTHLET_DEBUG) {
+	if (process.env.SLOTHLET_DEBUG === "1" || process.env.SLOTHLET_DEBUG === "true") {
 		console.log(`[slothlet] Cleaned up ${cleanedCount} listeners (${errorCount} errors)`);
 	}
 }

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

@@ -0,0 +1,237 @@
+/*
+	Copyright 2025 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.
+*/
+
+
+
+
+
+import fs from "node:fs/promises";
+import path from "node:path";
+import { resolvePathFromCaller } from "@cldmv/slothlet/helpers/resolve-from-caller";
+
+
+export async function addApiFromFolder({ apiPath, folderPath, instance }) {
+	if (!instance.loaded) {
+		throw new Error("[slothlet] Cannot add API: API not loaded. Call create() or load() first.");
+	}
+
+	
+	if (typeof apiPath !== "string") {
+		throw new TypeError("[slothlet] addApi: 'apiPath' must be a string.");
+	}
+	const normalizedApiPath = apiPath.trim();
+	if (normalizedApiPath === "") {
+		throw new TypeError("[slothlet] addApi: 'apiPath' must be a non-empty, non-whitespace string.");
+	}
+	const pathParts = normalizedApiPath.split(".");
+	if (pathParts.some((part) => part === "")) {
+		throw new Error(`[slothlet] addApi: 'apiPath' must not contain empty segments. Received: "${normalizedApiPath}"`);
+	}
+
+	
+	if (typeof folderPath !== "string") {
+		throw new TypeError("[slothlet] addApi: 'folderPath' must be a string.");
+	}
+
+	
+	let resolvedFolderPath = folderPath;
+	if (!path.isAbsolute(folderPath)) {
+		resolvedFolderPath = resolvePathFromCaller(folderPath);
+	}
+
+	
+	let stats;
+	try {
+		stats = await fs.stat(resolvedFolderPath);
+	} catch (error) {
+		throw new Error(`[slothlet] addApi: Cannot access folder: ${resolvedFolderPath} - ${error.message}`);
+	}
+	if (!stats.isDirectory()) {
+		throw new Error(`[slothlet] addApi: Path is not a directory: ${resolvedFolderPath}`);
+	}
+
+	if (instance.config.debug) {
+		console.log(`[DEBUG] addApi: Loading modules from ${resolvedFolderPath} to path: ${normalizedApiPath}`);
+	}
+
+	
+	let newModules;
+	if (instance.config.lazy) {
+		
+		newModules = await instance.modes.lazy.create.call(instance, resolvedFolderPath, instance.config.apiDepth || Infinity, 0);
+	} else {
+		
+		newModules = await instance.modes.eager.create.call(instance, resolvedFolderPath, instance.config.apiDepth || Infinity, 0);
+	}
+
+	if (instance.config.debug) {
+		if (newModules && typeof newModules === "object") {
+			console.log(`[DEBUG] addApi: Loaded modules:`, Object.keys(newModules));
+		} else {
+			console.log(
+				`[DEBUG] addApi: Loaded modules (non-object):`,
+				typeof newModules === "function" ? `[Function: ${newModules.name || "anonymous"}]` : newModules
+			);
+		}
+	}
+
+	
+	let currentTarget = instance.api;
+	let currentBoundTarget = instance.boundapi;
+
+	for (let i = 0; i < pathParts.length - 1; i++) {
+		const part = pathParts[i];
+		const key = instance._toapiPathKey(part);
+
+		
+		
+		
+		if (Object.prototype.hasOwnProperty.call(currentTarget, key)) {
+			const existing = currentTarget[key];
+			if (existing === null || (typeof existing !== "object" && typeof existing !== "function")) {
+				throw new Error(
+					`[slothlet] Cannot extend API path "${normalizedApiPath}" through segment "${part}": ` +
+						`existing value is type "${typeof existing}", cannot add properties.`
+				);
+			}
+			
+			
+		} else {
+			currentTarget[key] = {};
+		}
+		if (Object.prototype.hasOwnProperty.call(currentBoundTarget, key)) {
+			const existingBound = currentBoundTarget[key];
+			if (existingBound === null || (typeof existingBound !== "object" && typeof existingBound !== "function")) {
+				throw new Error(
+					`[slothlet] Cannot extend bound API path "${normalizedApiPath}" through segment "${part}": ` +
+						`existing value is type "${typeof existingBound}", cannot add properties.`
+				);
+			}
+			
+		} else {
+			currentBoundTarget[key] = {};
+		}
+
+		
+		currentTarget = currentTarget[key];
+		currentBoundTarget = currentBoundTarget[key];
+	}
+
+	
+	const finalKey = instance._toapiPathKey(pathParts[pathParts.length - 1]);
+
+	
+	if (typeof newModules === "function") {
+		
+		
+		if (Object.prototype.hasOwnProperty.call(currentTarget, finalKey)) {
+			const existing = currentTarget[finalKey];
+
+			
+			if (instance.config.allowApiOverwrite === false) {
+				console.warn(
+					`[slothlet] Skipping addApi: API path "${normalizedApiPath}" final key "${finalKey}" ` +
+						`already exists (type: "${typeof existing}"). Set allowApiOverwrite: true to allow overwrites.`
+				);
+				return; 
+			}
+
+			
+			if (existing !== null && typeof existing !== "function") {
+				console.warn(
+					`[slothlet] Overwriting existing non-function value at API path "${normalizedApiPath}" ` +
+						`final key "${finalKey}" with a function. Previous type: "${typeof existing}".`
+				);
+			} else if (typeof existing === "function") {
+				
+				console.warn(
+					`[slothlet] Overwriting existing function at API path "${normalizedApiPath}" ` + `final key "${finalKey}" with a new function.`
+				);
+			}
+		}
+		currentTarget[finalKey] = newModules;
+		currentBoundTarget[finalKey] = newModules;
+	} else if (typeof newModules === "object" && newModules !== null) {
+		
+		if (Object.prototype.hasOwnProperty.call(currentTarget, finalKey)) {
+			const existing = currentTarget[finalKey];
+
+			
+			if (instance.config.allowApiOverwrite === false && existing !== undefined && existing !== null) {
+				
+				const hasContent = typeof existing === "object" ? Object.keys(existing).length > 0 : true;
+				if (hasContent) {
+					console.warn(
+						`[slothlet] Skipping addApi merge: API path "${normalizedApiPath}" final key "${finalKey}" ` +
+							`already exists with content (type: "${typeof existing}"). Set allowApiOverwrite: true to allow merging.`
+					);
+					return; 
+				}
+			}
+
+			if (existing !== null && typeof existing !== "object" && typeof existing !== "function") {
+				throw new Error(
+					`[slothlet] Cannot merge API at "${normalizedApiPath}": ` +
+						`existing value at final key "${finalKey}" is type "${typeof existing}", cannot merge into primitives.`
+				);
+			}
+		}
+		if (Object.prototype.hasOwnProperty.call(currentBoundTarget, finalKey)) {
+			const existingBound = currentBoundTarget[finalKey];
+			if (existingBound !== null && typeof existingBound !== "object" && typeof existingBound !== "function") {
+				throw new Error(
+					`[slothlet] Cannot merge bound API at "${normalizedApiPath}": ` +
+						`existing value at final key "${finalKey}" is type "${typeof existingBound}", cannot merge into primitives.`
+				);
+			}
+		}
+
+		
+		if (!currentTarget[finalKey]) {
+			currentTarget[finalKey] = {};
+		}
+		if (!currentBoundTarget[finalKey]) {
+			currentBoundTarget[finalKey] = {};
+		}
+
+		
+		
+		
+		
+		
+		Object.assign(currentTarget[finalKey], newModules);
+		Object.assign(currentBoundTarget[finalKey], newModules);
+	} else if (newModules === null || newModules === undefined) {
+		
+		const receivedType = newModules === null ? "null" : "undefined";
+		console.warn(
+			`[slothlet] addApi: No modules loaded from folder at API path "${normalizedApiPath}". ` +
+				`Loaded modules resulted in ${receivedType}. Check that the folder contains valid module files.`
+		);
+	} else {
+		
+		
+		currentTarget[finalKey] = newModules;
+		currentBoundTarget[finalKey] = newModules;
+	}
+
+	
+	instance.updateBindings(instance.context, instance.reference, instance.boundapi);
+
+	if (instance.config.debug) {
+		console.log(`[DEBUG] addApi: Successfully added modules at ${normalizedApiPath}`);
+	}
+}