socket-function 1.2.9 → 1.2.11

package/SocketFunction.d.ts

@@ -1,6 +1,5 @@
 /// <reference path="require/RequireController.d.ts" />
 /// <reference types="node" />
-/// <reference types="node" />
 import { SocketExposedInterface, SocketFunctionHook, SocketFunctionClientHook, SocketExposedShape, SocketRegistered, CallerContext, FullCallType, SocketRegisterType } from "./SocketFunctionTypes";
 import { SocketServerConfig } from "./src/webSocketServer";
 import { Args, MaybePromise } from "./src/types";
@@ -11,11 +10,12 @@ type ExtractShape<ClassType, Shape> = {
 export declare class SocketFunction {
     static logMessages: boolean;
     static trackMessageSizes: {
-        upload: ((size: number) => void)[];
-        download: ((size: number) => void)[];
+        upload: ((size: number, nodeId: string) => void)[];
+        download: ((size: number, nodeId: string) => void)[];
         callTimes: ((obj: {
             start: number;
             end: number;
+            nodeId: string;
         }) => void)[];
     };
     static MAX_MESSAGE_SIZE: number;

package/SocketFunction.ts

@@ -58,9 +58,9 @@ type ExtractShape<ClassType, Shape> = {
 export class SocketFunction {
     public static logMessages = false;
     public static trackMessageSizes = {
-        upload: [] as ((size: number) => void)[],
-        download: [] as ((size: number) => void)[],
-        callTimes: [] as ((obj: { start: number; end: number; }) => void)[],
+        upload: [] as ((size: number, nodeId: string) => void)[],
+        download: [] as ((size: number, nodeId: string) => void)[],
+        callTimes: [] as ((obj: { start: number; end: number; nodeId: string; }) => void)[],
     };
 
     public static MAX_MESSAGE_SIZE = 1024 * 1024 * 32;

package/bin/upreal.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+
+require("typenode");
+require("../src/upreal");

package/index.d.ts

@@ -9,7 +9,6 @@ declare module "socket-function/SetProcessVariables" {
 declare module "socket-function/SocketFunction" {
     /// <reference path="require/RequireController.d.ts" />
     /// <reference types="node" />
-    /// <reference types="node" />
     import { SocketExposedInterface, SocketFunctionHook, SocketFunctionClientHook, SocketExposedShape, SocketRegistered, CallerContext, FullCallType, SocketRegisterType } from "socket-function/SocketFunctionTypes";
     import { SocketServerConfig } from "socket-function/src/webSocketServer";
     import { Args, MaybePromise } from "socket-function/src/types";
@@ -20,11 +19,12 @@ declare module "socket-function/SocketFunction" {
     export declare class SocketFunction {
         static logMessages: boolean;
         static trackMessageSizes: {
-            upload: ((size: number) => void)[];
-            download: ((size: number) => void)[];
+            upload: ((size: number, nodeId: string) => void)[];
+            download: ((size: number, nodeId: string) => void)[];
             callTimes: ((obj: {
                 start: number;
                 end: number;
+                nodeId: string;
             }) => void)[];
         };
         static MAX_MESSAGE_SIZE: number;
@@ -315,7 +315,6 @@ declare module "socket-function/require/CSSShim" {
 declare module "socket-function/require/RequireController" {
     /// <reference path="../../typenode/index.d.ts" />
     /// <reference types="node" />
-    /// <reference types="node" />
     declare global {
         namespace NodeJS {
             interface Module {
@@ -445,7 +444,6 @@ declare module "socket-function/require/compileFlags" {
 }
 
 declare module "socket-function/require/extMapper" {
-    /// <reference types="node" />
     /// <reference types="node" />
     export declare function getExtContentType(ext: string): string;
     export declare function getContentTypeFromBuffer(buffer: Buffer): string | undefined;
@@ -471,7 +469,6 @@ declare module "socket-function/require/require" {
 }
 
 declare module "socket-function/src/CallFactory" {
-    /// <reference types="node" />
     /// <reference types="node" />
     /// <reference types="node" />
     import { CallType } from "socket-function/SocketFunctionTypes";
@@ -530,7 +527,6 @@ declare module "socket-function/src/CallFactory" {
 }
 
 declare module "socket-function/src/JSONLACKS/JSONLACKS" {
-    /// <reference types="node" />
     /// <reference types="node" />
     export interface JSONLACKS_ParseConfig {
         extended?: boolean;
@@ -566,7 +562,6 @@ declare module "socket-function/src/JSONLACKS/JSONLACKS.generated.js" {
 }
 
 declare module "socket-function/src/Zip" {
-    /// <reference types="node" />
     /// <reference types="node" />
     import { MaybePromise } from "socket-function/src/types";
     export declare class Zip {
@@ -654,7 +649,6 @@ declare module "socket-function/src/batching" {
 }
 
 declare module "socket-function/src/bits" {
-    /// <reference types="node" />
     /// <reference types="node" />
     /** Subtracts the smallest possible value from a number (a double). This makes it possible to convert an exclusive range end
      *      to an inclusive range end, which is sometimes required (as in, < x is the same as <= minusEpsilon(x)).
@@ -681,7 +675,6 @@ declare module "socket-function/src/bits" {
 }
 
 declare module "socket-function/src/buffers" {
-    /// <reference types="node" />
     /// <reference types="node" />
     export type ArrayBufferViewTypes = Uint8Array | Int8Array | Uint16Array | Int16Array | Uint32Array | Int32Array | BigUint64Array | BigInt64Array | Float64Array | Float32Array | Uint8ClampedArray;
     export type BufferType = ArrayBuffer | SharedArrayBuffer | ArrayBufferViewTypes;
@@ -759,7 +752,6 @@ declare module "socket-function/src/caching" {
 }
 
 declare module "socket-function/src/callHTTPHandler" {
-    /// <reference types="node" />
     /// <reference types="node" />
     /// <reference types="node" />
     import http from "http";
@@ -814,7 +806,6 @@ declare module "socket-function/src/callManager" {
 }
 
 declare module "socket-function/src/certStore" {
-    /// <reference types="node" />
     /// <reference types="node" />
     /** Must be populated before the server starts */
     export declare function trustCertificate(cert: string | Buffer): void;
@@ -975,7 +966,6 @@ declare module "socket-function/src/getUniqueTime" {
 }
 
 declare module "socket-function/src/https" {
-    /// <reference types="node" />
     /// <reference types="node" />
     export declare function httpsRequest(url: string, payload?: Buffer | Buffer[], method?: string, sendSessionCookies?: boolean, config?: {
         headers?: {
@@ -987,7 +977,6 @@ declare module "socket-function/src/https" {
 }
 
 declare module "socket-function/src/lz4/LZ4" {
-    /// <reference types="node" />
     /// <reference types="node" />
     export declare class LZ4 {
         static compress(data: Buffer): Buffer;
@@ -1055,7 +1044,6 @@ declare module "socket-function/src/lz4/lz4_wasm_nodejs_bg.wasm" {
 }
 
 declare module "socket-function/src/misc" {
-    /// <reference types="node" />
     /// <reference types="node" />
     import { MaybePromise } from "socket-function/src/types";
     export declare const timeInSecond = 1000;
@@ -1485,7 +1473,6 @@ declare module "socket-function/src/storagePath" {
 }
 
 declare module "socket-function/src/tlsParsing" {
-    /// <reference types="node" />
     /// <reference types="node" />
     export declare function parseTLSHello(buffer: Buffer): {
         extensions: {
@@ -1509,8 +1496,12 @@ declare module "socket-function/src/types" {
 
 }
 
+declare module "socket-function/src/upreal" {
+    export {};
+
+}
+
 declare module "socket-function/src/webSocketServer" {
-    /// <reference types="node" />
     /// <reference types="node" />
     /// <reference types="node" />
     import https from "https";

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "socket-function",
-	"version": "1.2.9",
+	"version": "1.2.11",
 	"main": "index.js",
 	"license": "MIT",
 	"dependencies": {
@@ -12,13 +12,17 @@
 		"preact": "10.24.3",
 		"typedev": "^0.4.0",
 		"typenode": "^6.0.1",
-		"ws": "^8.17.1"
+		"ws": "^8.21.0"
 	},
 	"optionalDependencies": {
 		"lmdb": "^3.5.1"
 	},
 	"types": "index.d.ts",
+	"bin": {
+		"upreal": "./bin/upreal.js"
+	},
 	"scripts": {
+		"upreal": "yarn typenode ./src/upreal.ts",
 		"test": "yarn typenode ./test.ts",
 		"test-all": "node run-test.js",
 		"type": "yarn tsc --noEmit",

package/require/RequireController.d.ts

@@ -1,6 +1,5 @@
 /// <reference path="../../typenode/index.d.ts" />
 /// <reference types="node" />
-/// <reference types="node" />
 declare global {
     namespace NodeJS {
         interface Module {

package/require/extMapper.d.ts

@@ -1,4 +1,3 @@
 /// <reference types="node" />
-/// <reference types="node" />
 export declare function getExtContentType(ext: string): string;
 export declare function getContentTypeFromBuffer(buffer: Buffer): string | undefined;

package/src/CallFactory.d.ts

@@ -1,6 +1,5 @@
 /// <reference types="node" />
 /// <reference types="node" />
-/// <reference types="node" />
 import { CallType } from "../SocketFunctionTypes";
 import * as ws from "ws";
 import * as tls from "tls";

package/src/CallFactory.ts

@@ -277,7 +277,7 @@ export async function createCallFactory(
             {
                 let resultSize = data.map(x => x.length).reduce((a, b) => a + b, 0);
                 for (let callback of SocketFunction.trackMessageSizes.upload) {
-                    callback(resultSize);
+                    callback(resultSize, nodeId);
                 }
                 if (SocketFunction.logMessages) {
                     let fncHack = "";
@@ -568,7 +568,7 @@ export async function createCallFactory(
         }
         let parseTime = Date.now() - time;
         for (let callback of SocketFunction.trackMessageSizes.download) {
-            callback(resultSize);
+            callback(resultSize, nodeId);
         }
 
         let receiveStats: CompressionStats = {
@@ -659,7 +659,7 @@ export async function createCallFactory(
                 let start = time;
                 let end = Date.now();
                 for (let fnc of SocketFunction.trackMessageSizes.callTimes) {
-                    fnc({ start, end });
+                    fnc({ start, end, nodeId });
                 }
             }
 

package/src/JSONLACKS/JSONLACKS.d.ts

@@ -1,5 +1,4 @@
 /// <reference types="node" />
-/// <reference types="node" />
 export interface JSONLACKS_ParseConfig {
     extended?: boolean;
     discardMissingReferences?: boolean;

package/src/Zip.d.ts

@@ -1,5 +1,4 @@
 /// <reference types="node" />
-/// <reference types="node" />
 import { MaybePromise } from "./types";
 export declare class Zip {
     static gzip(buffer: Buffer, level?: number): Promise<Buffer>;

package/src/bits.d.ts

@@ -1,5 +1,4 @@
 /// <reference types="node" />
-/// <reference types="node" />
 /** Subtracts the smallest possible value from a number (a double). This makes it possible to convert an exclusive range end
  *      to an inclusive range end, which is sometimes required (as in, < x is the same as <= minusEpsilon(x)).
  */

package/src/buffers.d.ts

@@ -1,5 +1,4 @@
 /// <reference types="node" />
-/// <reference types="node" />
 export type ArrayBufferViewTypes = Uint8Array | Int8Array | Uint16Array | Int16Array | Uint32Array | Int32Array | BigUint64Array | BigInt64Array | Float64Array | Float32Array | Uint8ClampedArray;
 export type BufferType = ArrayBuffer | SharedArrayBuffer | ArrayBufferViewTypes;
 export declare function cloneBuffer(data: Buffer): Buffer;

package/src/callHTTPHandler.d.ts

@@ -1,6 +1,5 @@
 /// <reference types="node" />
 /// <reference types="node" />
-/// <reference types="node" />
 import http from "http";
 import { CallType } from "../SocketFunctionTypes";
 export declare function setDefaultHTTPCall(call: CallType): void;

package/src/certStore.d.ts

@@ -1,5 +1,4 @@
 /// <reference types="node" />
-/// <reference types="node" />
 /** Must be populated before the server starts */
 export declare function trustCertificate(cert: string | Buffer): void;
 export declare function getTrustedCertificates(): string[];

package/src/https.d.ts

@@ -1,5 +1,4 @@
 /// <reference types="node" />
-/// <reference types="node" />
 export declare function httpsRequest(url: string, payload?: Buffer | Buffer[], method?: string, sendSessionCookies?: boolean, config?: {
     headers?: {
         [key: string]: string | undefined;

package/src/lz4/LZ4.d.ts

@@ -1,5 +1,4 @@
 /// <reference types="node" />
-/// <reference types="node" />
 export declare class LZ4 {
     static compress(data: Buffer): Buffer;
     static compressUntracked(data: Buffer): Buffer;

package/src/misc.d.ts

@@ -1,5 +1,4 @@
 /// <reference types="node" />
-/// <reference types="node" />
 import { MaybePromise } from "./types";
 export declare const timeInSecond = 1000;
 export declare const timeInMinute: number;

package/src/tlsParsing.d.ts

@@ -1,5 +1,4 @@
 /// <reference types="node" />
-/// <reference types="node" />
 export declare function parseTLSHello(buffer: Buffer): {
     extensions: {
         type: number;

package/src/upreal.d.ts

@@ -0,0 +1 @@
+export {};

package/src/upreal.ts

@@ -0,0 +1,197 @@
+import * as fs from "fs";
+import * as path from "path";
+import * as https from "https";
+import { spawn } from "child_process";
+
+// Dependency sections in package.json that upreal is willing to update, in the order we search them.
+const DEP_SECTIONS = [
+    "dependencies",
+    "devDependencies",
+    "optionalDependencies",
+    "peerDependencies",
+] as const;
+
+async function main() {
+    let packageName = process.argv.slice(2).find(arg => !arg.startsWith("-"));
+    if (!packageName) {
+        console.error("Usage: yarn upreal <package-name>");
+        process.exit(1);
+        return;
+    }
+
+    let projectRoot = process.cwd();
+    let packageJsonPath = path.join(projectRoot, "package.json");
+    let lockPath = path.join(projectRoot, "yarn.lock");
+
+    let packageJsonRaw = fs.readFileSync(packageJsonPath, "utf8");
+    let packageJson = JSON.parse(packageJsonRaw) as {
+        [section: string]: { [name: string]: string } | undefined;
+    };
+
+    let currentRange = findCurrentRange(packageJson, packageName);
+    if (currentRange === undefined) {
+        console.error(`Package "${packageName}" is not listed in ${DEP_SECTIONS.join(", ")} of package.json`);
+        process.exit(1);
+        return;
+    }
+
+    console.log(`Current range for ${packageName}: ${currentRange}`);
+
+    let latest = await getLatestVersion(packageName);
+    console.log(`Latest version of ${packageName}: ${latest}`);
+
+    let newRange = applyPrefix(currentRange, latest);
+    if (newRange === currentRange) {
+        console.log(`package.json range unchanged (${currentRange}); will still re-resolve the lockfile.`);
+    } else {
+        packageJsonRaw = replaceRange(packageJsonRaw, packageName, currentRange, newRange);
+        fs.writeFileSync(packageJsonPath, packageJsonRaw);
+        console.log(`Updated package.json: ${packageName} ${currentRange} -> ${newRange}`);
+    }
+
+    // Drop every lockfile entry for this package so `yarn install` re-resolves each of its ranges (ours and any
+    // transitive ones) to the newest version they can reach. This is what makes "everything that could be updated"
+    // update in one shot, rather than yarn pinning the previously-locked versions.
+    if (fs.existsSync(lockPath)) {
+        let lockRaw = fs.readFileSync(lockPath, "utf8");
+        let { lock, removed } = removeLockEntries(lockRaw, packageName);
+        if (removed > 0) {
+            fs.writeFileSync(lockPath, lock);
+            console.log(`Removed ${removed} lockfile entr${removed === 1 ? "y" : "ies"} for ${packageName} so they re-resolve.`);
+        }
+    }
+
+    console.log(`Running yarn install...`);
+    await runYarnInstall(projectRoot);
+    console.log(`Done. ${packageName} is now at ${newRange}.`);
+}
+
+function findCurrentRange(
+    packageJson: { [section: string]: { [name: string]: string } | undefined },
+    packageName: string
+): string | undefined {
+    for (let section of DEP_SECTIONS) {
+        let deps = packageJson[section];
+        if (deps && packageName in deps) {
+            return deps[packageName];
+        }
+    }
+    return undefined;
+}
+
+async function getLatestVersion(packageName: string): Promise<string> {
+    // Scoped names ("@scope/name") must have their slash encoded in the registry path.
+    let encodedName = packageName.startsWith("@")
+        ? "@" + encodeURIComponent(packageName.slice(1))
+        : encodeURIComponent(packageName);
+    let url = `https://registry.npmjs.org/${encodedName}/latest`;
+
+    let body = await new Promise<string>((resolve, reject) => {
+        https.get(url, res => {
+            if (res.statusCode !== 200) {
+                res.resume();
+                reject(new Error(`Registry returned ${res.statusCode} for ${url}`));
+                return;
+            }
+            let chunks: Buffer[] = [];
+            res.on("data", chunk => chunks.push(chunk));
+            res.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
+        }).on("error", reject);
+    });
+
+    let parsed = JSON.parse(body) as { version?: string };
+    if (!parsed.version) {
+        throw new Error(`Registry response for ${packageName} had no version field`);
+    }
+    return parsed.version;
+}
+
+// Keep whatever range operator the user already chose (^, ~, exact, or *) and point it at the new version.
+function applyPrefix(currentRange: string, latest: string): string {
+    if (currentRange === "*" || currentRange === "" || currentRange === "latest") {
+        return currentRange;
+    }
+    if (currentRange.startsWith("^")) {
+        return "^" + latest;
+    }
+    if (currentRange.startsWith("~")) {
+        return "~" + latest;
+    }
+    return latest;
+}
+
+function replaceRange(packageJsonRaw: string, packageName: string, oldRange: string, newRange: string): string {
+    // Rewrite the value in place (rather than JSON.stringify) so the file keeps its exact formatting and tab style.
+    let keyPattern = new RegExp(`("${escapeRegExp(packageName)}"\\s*:\\s*")${escapeRegExp(oldRange)}(")`);
+    if (!keyPattern.test(packageJsonRaw)) {
+        throw new Error(`Could not locate "${packageName}": "${oldRange}" in package.json to update`);
+    }
+    return packageJsonRaw.replace(keyPattern, `$1${newRange}$2`);
+}
+
+// Remove all yarn.lock v1 blocks that resolve the given package (across every range variant of it).
+function removeLockEntries(lockRaw: string, packageName: string): { lock: string; removed: number } {
+    // yarn.lock v1 blocks are separated by blank lines; the first line of each block is the comma-separated
+    // list of specs it satisfies, e.g. `"pkg@^1.0.0", "pkg@~1.2.0":`.
+    let blocks = lockRaw.split(/\r?\n\r?\n/);
+    let removed = 0;
+    let kept: string[] = [];
+    for (let block of blocks) {
+        if (blockResolvesPackage(block, packageName)) {
+            removed++;
+            continue;
+        }
+        kept.push(block);
+    }
+    return { lock: kept.join("\n\n"), removed };
+}
+
+function blockResolvesPackage(block: string, packageName: string): boolean {
+    let headerLine = block.split(/\r?\n/).find(line => line.trim().length > 0 && !line.startsWith("#"));
+    if (!headerLine || !headerLine.trimEnd().endsWith(":")) {
+        return false;
+    }
+    // Strip the trailing colon, then split on commas into individual quoted-or-bare specs.
+    let specsPart = headerLine.trimEnd().replace(/:$/, "");
+    let specs = specsPart.split(",").map(spec => spec.trim().replace(/^"|"$/g, ""));
+    for (let spec of specs) {
+        if (specNamePackage(spec) === packageName) {
+            return true;
+        }
+    }
+    return false;
+}
+
+// Extract the package name from a lock spec like `@scope/name@^1.0.0` or `name@~1.2.0`.
+function specNamePackage(spec: string): string {
+    let atIndex = spec.lastIndexOf("@");
+    // A leading "@" (scoped package) is part of the name, not the name/range separator.
+    if (atIndex <= 0) {
+        return spec;
+    }
+    return spec.slice(0, atIndex);
+}
+
+function escapeRegExp(value: string): string {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+async function runYarnInstall(cwd: string): Promise<void> {
+    await new Promise<void>((resolve, reject) => {
+        // yarn is a .cmd shim on Windows, so it must be spawned through the shell.
+        let child = spawn("yarn", ["install"], { cwd, stdio: "inherit", shell: true });
+        child.on("error", reject);
+        child.on("exit", code => {
+            if (code === 0) {
+                resolve();
+            } else {
+                reject(new Error(`yarn install exited with code ${code}`));
+            }
+        });
+    });
+}
+
+main().catch(e => {
+    console.error(e.stack ?? e);
+    process.exit(1);
+});

package/src/webSocketServer.d.ts

@@ -1,6 +1,5 @@
 /// <reference types="node" />
 /// <reference types="node" />
-/// <reference types="node" />
 import https from "https";
 import { Watchable } from "./misc";
 export type SocketServerConfig = (https.ServerOptions & {