querysub 0.3.0 → 0.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "querysub",
-    "version": "0.3.0",
+    "version": "0.5.0",
     "main": "index.js",
     "license": "MIT",
     "note1": "note on node-forge fork, see https://github.com/digitalbazaar/forge/issues/744 for details",
@@ -24,7 +24,7 @@
         "node-forge": "https://github.com/sliftist/forge#e618181b469b07bdc70b968b0391beb8ef5fecd6",
         "pako": "^2.1.0",
         "preact": "^10.11.3",
-        "socket-function": "^0.32.0",
+        "socket-function": "^0.33.0",
         "terser": "^5.31.0",
         "typesafecss": "^0.6.3",
         "yaml": "^2.5.0",

package/src/-a-archives/archiveCache.ts

@@ -1,24 +1,16 @@
 import { getStorageDir, getSubFolder } from "../fs";
 import { Archives } from "./archives";
-import { diskEscapeFileName, getArchivesLocal } from "./archivesDisk";
 import fs from "fs";
 
-import diskusage from "diskusage";
-import { binarySearchBasic, binarySearchIndex, list, nextId, sort, timeInHour, timeInMinute } from "socket-function/src/misc";
+import { list, nextId, timeInHour, timeInMinute } from "socket-function/src/misc";
 import { cache, lazy } from "socket-function/src/caching";
-import { delay, runInSerial, runInfinitePoll } from "socket-function/src/batching";
+import { runInSerial, runInfinitePoll } from "socket-function/src/batching";
 import { sha256 } from "js-sha256";
-import { devDebugbreak } from "../config";
 import child_process from "child_process";
-import os from "os";
-import fsext, { flock } from "fs-ext";
-import debugbreak from "debugbreak";
-import readline from "readline";
 import { getPPID } from "../misc/getParentProcessId";
 import { Args } from "socket-function/src/types";
 import { getArchivesBackblaze } from "./archivesBackBlaze";
-import { logErrors } from "../errors";
-import { formatNumber, formatTime } from "socket-function/src/formatting/format";
+import { formatNumber } from "socket-function/src/formatting/format";
 import { SizeLimiter } from "../diagnostics/SizeLimiter";
 
 const SIZE_LIMIT = new SizeLimiter({
@@ -702,6 +694,7 @@ async function isLocked(path: string, operation?: {
     return await lockRetryLoop(async function isLocked() {
         let handle = await getHandle(lockPath);
         try {
+            const { flock } = await import("fs-ext");
             await new Promise<void>((r, e) => flock(handle.fd, "ex", err => err ? e(err) : r()));
             let contents = (await handle.readFile()).toString();
             let locks = contents.toString().replaceAll("\0", "").trim().split("\n").filter(x => x);

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

@@ -17,6 +17,7 @@ import { getPathStr2, getPathStr3 } from "../path";
 import { consistentHash } from "../misc/hash";
 import { setExternalHotReloading } from "socket-function/hot/HotReloadController";
 import { isPublic } from "../config";
+import { SocketFunction } from "socket-function/SocketFunction";
 
 // Get localPathRemappings using yargs, so it is easy to configure in multiple entry points
 let yargObj = isNodeTrue() && yargs(process.argv)
@@ -119,11 +120,6 @@ export function setGitURLMapping(config: {
 
 /** spec => path that we can use with require */
 let moduleResolver = async (spec: FunctionSpec) => {
-    //todonext;
-    //  I think the cloning isn't working?
-    debugbreak(2);
-    debugger;
-
     let gitURL = spec.gitURL;
     let urlForPath = gitURL;
 
@@ -141,16 +137,23 @@ let moduleResolver = async (spec: FunctionSpec) => {
     if (urlForPath.endsWith(".git")) {
         urlForPath = urlForPath.slice(0, -".git".length);
     }
-    let repoPath = getSubFolder("synced_repos") + urlForPath + "/" + spec.gitRef;
+    let repoPath = getSubFolder("synced_repos") + urlForPath + "/" + spec.gitRef + "/";
     if (!fs.existsSync(repoPath)) {
         await executeCommand("git", ["clone", gitURL, repoPath]);
         await executeCommand("git", ["reset", "--hard", spec.gitRef], { cwd: repoPath });
     }
     if (!fs.existsSync(repoPath + "node_modules")) {
-        // NOTE: `--ignore-scripts` to make installing faster, as presently a slow install step will cause functions
-        //  after a new deploy to timeout for a bit.
-        await executeCommand("yarn", ["install", "--ignore-scripts"], { cwd: repoPath });
+        await executeCommand("yarn", ["install"], { cwd: repoPath });
+    }
+    let querysubPath = repoPath + "node_modules/querysub";
+    if (fs.existsSync(querysubPath)) {
+        // By moving querysub, it forces the repo to use the parent querysub. This is nice, as it even
+        //  works when this code is required clientside!
+        //  - Recursive deletes are slow, but moving is fast, so just move it. This repos don't update anyways
+        //      (we have one per hash), so it's not this will fill up with moved files.
+        await fs.promises.rename(querysubPath, querysubPath + "_" + Date.now());
     }
+
     return repoPath;
 };
 
@@ -160,6 +163,7 @@ async function getModuleFromSpecBase(
 ): Promise<NodeJS.Module> {
     let hotReloadPackagePath = "";
     let path = gitURLRefMappings.get(getSpecKey(spec));
+    let deployPath = "";
     if (!path) {
         // Sync the git repo, `yarn install --ignore-scripts`, require the path, get the export, and then return that function.
         let packagePath = getLocalPathRemapping()[spec.gitURL];
@@ -177,11 +181,19 @@ async function getModuleFromSpecBase(
             specFilePath = specFilePath.slice(1);
         }
         path = packagePath + specFilePath;
+        deployPath = packagePath + "deploy.ts";
     }
     console.log(blue(`require(${JSON.stringify(path)})`));
     try {
-        // NOTE: The true tells require to not warn about the async loading
-        await (require as any)(path, 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.
+            if (deployPath) {
+                await (require as any)(deployPath, true);
+            }
+            // NOTE: The true tells require to not warn about the async loading
+            await (require as any)(path, true);
+        });
     } catch (e: any) {
 
         throw new Error(`Error when loading function for ${JSON.stringify(path)}:${spec.FunctionId}\n${e.stack}`);