querysub 0.6.0 → 0.8.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "querysub",
-    "version": "0.6.0",
+    "version": "0.8.0",
     "main": "index.js",
     "license": "MIT",
     "note1": "note on node-forge fork, see https://github.com/digitalbazaar/forge/issues/744 for details",

package/src/3-path-functions/pathFunctionLoader.ts

@@ -157,12 +157,29 @@ let moduleResolver = async (spec: FunctionSpec) => {
     return repoPath;
 };
 
-let key = "isInNestedImport-302fec38-0443-44f7-b31f-1f514900437f";
-function setInNestedImport(value: boolean) {
-    (globalThis as any)[key] = value;
+export function isDynamicModule(module: NodeJS.Module): boolean {
+    return isDynamicModulePath(module.filename);
 }
-export function isInNestedImport(): boolean {
-    return !!(globalThis as any)[key];
+export function isDynamicModulePath(path: string): boolean {
+    let parts = path.replaceAll("\\", "/").split("/");
+    return parts.includes("node_modules") || parts.includes("synced_repos");
+}
+/** Annoying, and slower than isDynamicModule, but... necessary. We can't expect the user to call isDynamicModule,
+ *      and our functions will all resolve to the root on purpose, so... we need to check the callstack!
+ */
+export function isCallerDynamicModule(): boolean {
+    return getCallstackFiles().some(isDynamicModulePath);
+}
+function getCallstackFiles(): string[] {
+    let stack = new Error().stack;
+    if (!stack) return [];
+    let lines = stack.split("\n");
+    let files = lines.map(line => {
+        let match = line.match(/\(([^)]+)\)/);
+        if (!match) return "";
+        return match[1];
+    });
+    return files;
 }
 
 async function getModuleFromSpecBase(
@@ -192,7 +209,6 @@ async function getModuleFromSpecBase(
     }
     console.log(blue(`require(${JSON.stringify(path)})`));
     try {
-        setInNestedImport(true);
         await SocketFunction.ignoreExposeCalls(async () => {
             // Import deploy, which should always exist, and provides a consistent
             //  import order, fixing a lot of cyclic / module level code logic issues.
@@ -204,8 +220,6 @@ async function getModuleFromSpecBase(
         });
     } catch (e: any) {
         throw new Error(`Error when loading function for ${JSON.stringify(path)}:${spec.FunctionId}\n${e.stack}`);
-    } finally {
-        setInNestedImport(false);
     }
     let moduleId = require.resolve(path) || path;
     let module = require.cache[moduleId];

package/src/4-querysub/Querysub.ts

@@ -49,6 +49,7 @@ import { devDebugbreak, getDomain, isDevDebugbreak, isNoNetwork, isPublic } from
 import { hookErrors } from "../diagnostics/errorLogs/hookErrors";
 import { Schema2, Schema2T, t } from "../2-proxy/schema2";
 import { CALL_PERMISSIONS_KEY } from "./permissionsShared";
+import { isDynamicModule } from "../3-path-functions/pathFunctionLoader";
 
 export { t };
 

package/src/5-diagnostics/qreactDebug.tsx

@@ -16,7 +16,7 @@ import { PathValueProxyWatcher } from "../2-proxy/PathValueProxyWatcher";
 import { InputLabel, InputLabelURL } from "../library-components/InputLabel";
 import { URLParam } from "../library-components/URLParam";
 import { hotReloadingGuard, isHotReloading, onHotReload } from "socket-function/hot/HotReloadController";
-import { isInNestedImport } from "../3-path-functions/pathFunctionLoader";
+import { isCallerDynamicModule, isDynamicModule } from "../3-path-functions/pathFunctionLoader";
 
 // Map, so hot reloading doesn't break things
 let componentButtons = new Map<string, { title: string, callback: (component: ExternalRenderClass) => void }>();
@@ -25,7 +25,7 @@ export function addComponentButton(config: {
     title: string;
     callback: (component: ExternalRenderClass) => void;
 }) {
-    if (isInNestedImport()) return;
+    if (isCallerDynamicModule(module)) return;
     if (!isHotReloading() && componentButtons.has(config.title)) {
         throw new Error(`Component button with title ${config.title} already exists`);
     }