socket-function 1.2.34 → 1.2.36

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";

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";
@@ -321,7 +320,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 {
@@ -451,7 +449,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;
@@ -477,7 +474,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";
@@ -536,7 +532,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;
@@ -572,7 +567,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 {
@@ -660,7 +654,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)).
@@ -687,7 +680,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;
@@ -765,7 +757,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";
@@ -820,7 +811,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;
@@ -1056,7 +1046,6 @@ declare module "socket-function/src/getUniqueTime" {
 }
 
 declare module "socket-function/src/https" {
-    /// <reference types="node" />
     /// <reference types="node" />
     export interface HttpsResponseInfo {
         statusCode?: number;
@@ -1076,7 +1065,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;
@@ -1144,7 +1132,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;
@@ -1510,6 +1497,7 @@ declare module "socket-function/src/runPromise" {
         quiet?: boolean;
         nothrow?: boolean;
         detach?: boolean;
+        includeStderrInOutput?: boolean;
     }): Promise<string>;
 
 }
@@ -1575,7 +1563,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: {
@@ -1605,7 +1592,6 @@ declare module "socket-function/src/upreal" {
 }
 
 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.34",
+	"version": "1.2.36",
 	"main": "index.js",
 	"license": "MIT",
 	"dependencies": {

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/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 interface HttpsResponseInfo {
     statusCode?: number;
     statusMessage?: string;

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/runPromise.d.ts

@@ -4,4 +4,5 @@ export declare function runPromise(command: string, config?: {
     quiet?: boolean;
     nothrow?: boolean;
     detach?: boolean;
+    includeStderrInOutput?: boolean;
 }): Promise<string>;

package/src/runPromise.ts

@@ -9,6 +9,7 @@ export async function runPromise(command: string, config?: {
     // Never throw, just return the full output
     nothrow?: boolean;
     detach?: boolean;
+    includeStderrInOutput?: boolean;
 }) {
     return new Promise<string>((resolve, reject) => {
         if (!config?.quiet) {
@@ -38,7 +39,9 @@ export async function runPromise(command: string, config?: {
         childProc.stderr?.on("data", (data) => {
             const chunk = data.toString();
             stderr += chunk;
-            fullOutput += chunk;
+            if (config?.includeStderrInOutput) {
+                fullOutput += chunk;
+            }
 
             // Stream to console unless quiet mode
             if (!config?.quiet) {

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.ts

@@ -11,10 +11,23 @@ const DEP_SECTIONS = [
     "peerDependencies",
 ] as const;
 
+// yarn can re-fetch a requesting package's real manifest (instead of trusting our rewritten lockfile entry),
+//  which re-introduces the old pinned range. Re-running the rewrite converges then, so allow a few passes.
+const MAX_DEDUPE_PASSES = 3;
+
+// Depth at which yarn.lock lists a block's dependencies. Block fields ("version", "resolved") sit shallower,
+//  so this is what keeps us from mistaking a field for a dependency entry.
+const LOCK_DEPENDENCY_INDENT = 4;
+
+// Yarn itself spells this "--dry-run", so accept that plus every spelling anyone reasonably reaches for.
+const DRY_RUN_FLAGS = ["--dry", "-dry", "--dryrun", "-dryrun", "--dry-run", "-dry-run", "--dry_run", "-dry_run"];
+
 async function main() {
-    let packageName = process.argv.slice(2).find(arg => !arg.startsWith("-"));
+    let args = process.argv.slice(2);
+    let packageName = args.find(arg => !arg.startsWith("-"));
+    let dryRun = args.some(arg => DRY_RUN_FLAGS.includes(arg.toLowerCase()));
     if (!packageName) {
-        console.error("Usage: yarn upreal <package-name>");
+        console.error("Usage: yarn upreal <package-name> [--dry-run]");
         process.exit(1);
         return;
     }
@@ -23,60 +36,73 @@ async function main() {
     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 latest = await getLatestVersion(packageName);
+    console.log(`Latest version of ${packageName}: ${latest}`);
 
-    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;
-    }
+    let newRange = updatePackageJson(packageJsonPath, packageName, latest);
+    console.log(`Forcing every reference to ${packageName} onto ${newRange}`);
+
+    for (let pass = 1; pass <= MAX_DEDUPE_PASSES; pass++) {
+        if (fs.existsSync(lockPath)) {
+            let result = forceLockRange(lockPath, packageName, newRange);
+            console.log(`Lockfile pass ${pass}: dropped ${result.removedBlocks} entr${result.removedBlocks === 1 ? "y" : "ies"} for ${packageName}, repointed ${result.rewrittenRequests} request${result.rewrittenRequests === 1 ? "" : "s"} for it to ${newRange}.`);
+            for (let skipped of result.skippedRequests) {
+                console.log(`Left ${skipped.requestedBy} asking for ${packageName}@${skipped.range} (not a registry range, so it can't be moved).`);
+            }
+        }
 
-    console.log(`Current range for ${packageName}: ${currentRange}`);
+        if (dryRun) {
+            console.log(`Dry run: package.json and yarn.lock are rewritten, skipping yarn install.`);
+            return;
+        }
 
-    let latest = await getLatestVersion(packageName);
-    console.log(`Latest version of ${packageName}: ${latest}`);
+        console.log(`Running yarn install...`);
+        await runYarnInstall(projectRoot);
 
-    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.`);
+        let versions = getLockedVersions(lockPath, packageName);
+        if (versions.length <= 1) {
+            console.log(`Done. ${packageName} resolves to a single version: ${versions[0] ?? latest}`);
+            return;
         }
+        console.log(`${packageName} still resolves to ${versions.length} versions (${versions.join(", ")}); rewriting again.`);
     }
 
-    console.log(`Running yarn install...`);
-    await runYarnInstall(projectRoot);
-    console.log(`Done. ${packageName} is now at ${newRange}.`);
+    let versions = getLockedVersions(lockPath, packageName);
+    console.error(`Failed to collapse ${packageName} onto one version after ${MAX_DEDUPE_PASSES} passes; still at ${versions.join(", ")}`);
+    process.exit(1);
 }
 
-function findCurrentRange(
-    packageJson: { [section: string]: { [name: string]: string } | undefined },
-    packageName: string
-): string | undefined {
+// Point every package.json section that mentions the package at the latest version, keeping each section's
+//  existing range operator, and return the range we are forcing everything else onto.
+function updatePackageJson(packageJsonPath: string, packageName: string, latest: string): string {
+    let raw = fs.readFileSync(packageJsonPath, "utf8");
+    let packageJson = JSON.parse(raw) as {
+        [section: string]: { [name: string]: string } | undefined;
+    };
+
+    let newRange: string | undefined;
     for (let section of DEP_SECTIONS) {
         let deps = packageJson[section];
-        if (deps && packageName in deps) {
-            return deps[packageName];
+        if (!deps || !(packageName in deps)) {
+            continue;
+        }
+        let currentRange = deps[packageName];
+        let sectionRange = applyPrefix(currentRange, latest);
+        newRange = newRange ?? sectionRange;
+        if (sectionRange === currentRange) {
+            console.log(`package.json ${section}.${packageName} already ${currentRange}`);
+            continue;
         }
+        raw = replaceRange(raw, packageName, currentRange, sectionRange);
+        fs.writeFileSync(packageJsonPath, raw);
+        console.log(`Updated package.json ${section}.${packageName}: ${currentRange} -> ${sectionRange}`);
+    }
+
+    if (newRange === undefined) {
+        console.log(`${packageName} is not a direct dependency; only deduplicating transitive references.`);
+        return "^" + latest;
     }
-    return undefined;
+    return newRange;
 }
 
 async function getLatestVersion(packageName: string): Promise<string> {
@@ -120,37 +146,50 @@ function replaceRange(packageJsonRaw: string, packageName: string, oldRange: str
     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;
+interface LockBlock {
+    // Index of the header line, and the exclusive end of the block (trailing blank lines included).
+    start: number;
+    end: number;
+    specs: string[];
+}
+
+interface LockFile {
+    lines: string[];
+    eol: string;
+    blocks: LockBlock[];
+}
+
+function readLock(lockPath: string): LockFile {
+    let raw = fs.readFileSync(lockPath, "utf8");
+    let eol = raw.includes("\r\n") ? "\r\n" : "\n";
+    let lines = raw.split(/\r?\n/);
+
+    let blocks: LockBlock[] = [];
+    let current: LockBlock | undefined;
+    for (let i = 0; i < lines.length; i++) {
+        let line = lines[i];
+        if (isBlockHeader(line)) {
+            if (current) {
+                current.end = i;
+            }
+            current = { start: i, end: lines.length, specs: parseHeaderSpecs(line) };
+            blocks.push(current);
         }
-        kept.push(block);
     }
-    return { lock: kept.join("\n\n"), removed };
+    return { lines, eol, blocks };
 }
 
-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(":")) {
+function isBlockHeader(line: string): boolean {
+    if (!line || line.startsWith("#") || /^\s/.test(line)) {
         return false;
     }
-    // Strip the trailing colon, then split on commas into individual quoted-or-bare specs.
+    return line.trimEnd().endsWith(":");
+}
+
+function parseHeaderSpecs(headerLine: string): string[] {
+    // e.g. `"pkg@^1.0.0", "pkg@~1.2.0":` -> ["pkg@^1.0.0", "pkg@~1.2.0"]
     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;
+    return specsPart.split(",").map(spec => spec.trim().replace(/^"|"$/g, ""));
 }
 
 // Extract the package name from a lock spec like `@scope/name@^1.0.0` or `name@~1.2.0`.
@@ -163,6 +202,89 @@ function specNamePackage(spec: string): string {
     return spec.slice(0, atIndex);
 }
 
+// Ranges that don't come from the registry (git urls, file:, link:, npm: aliases) can't be pointed at a
+//  version number, so they have to stay as they are.
+function isRegistryRange(range: string): boolean {
+    return !range.includes(":") && !range.includes("/");
+}
+
+// Force the whole tree onto one version: drop every block for the package (so yarn re-resolves it), and
+//  repoint every *other* block's request for it at the new range, so nothing is left asking for an old
+//  pinned version that yarn would then have to resolve into a second entry.
+function forceLockRange(lockPath: string, packageName: string, newRange: string): {
+    removedBlocks: number;
+    rewrittenRequests: number;
+    skippedRequests: { requestedBy: string; range: string }[];
+} {
+    let lock = readLock(lockPath);
+    let removeLines = new Set<number>();
+    let removedBlocks = 0;
+    let rewrittenRequests = 0;
+    let skippedRequests: { requestedBy: string; range: string }[] = [];
+
+    for (let block of lock.blocks) {
+        if (block.specs.some(spec => specNamePackage(spec) === packageName)) {
+            removedBlocks++;
+            for (let i = block.start; i < block.end; i++) {
+                removeLines.add(i);
+            }
+            continue;
+        }
+
+        for (let i = block.start + 1; i < block.end; i++) {
+            let parsed = parseDependencyLine(lock.lines[i]);
+            if (!parsed || parsed.name !== packageName) {
+                continue;
+            }
+            if (!isRegistryRange(parsed.range)) {
+                skippedRequests.push({ requestedBy: block.specs[0], range: parsed.range });
+                continue;
+            }
+            if (parsed.range === newRange) {
+                continue;
+            }
+            lock.lines[i] = parsed.prefix + `"${newRange}"`;
+            rewrittenRequests++;
+        }
+    }
+
+    let kept = lock.lines.filter((_, i) => !removeLines.has(i));
+    fs.writeFileSync(lockPath, kept.join(lock.eol));
+    return { removedBlocks, rewrittenRequests, skippedRequests };
+}
+
+function parseDependencyLine(line: string): { prefix: string; name: string; range: string } | undefined {
+    let match = /^(\s+)("?)([^"\s]+)\2 "([^"]*)"$/.exec(line);
+    if (!match) {
+        return undefined;
+    }
+    let [, indent, quote, name, range] = match;
+    if (indent.length < LOCK_DEPENDENCY_INDENT) {
+        return undefined;
+    }
+    return { prefix: `${indent}${quote}${name}${quote} `, name, range };
+}
+
+function getLockedVersions(lockPath: string, packageName: string): string[] {
+    if (!fs.existsSync(lockPath)) {
+        return [];
+    }
+    let lock = readLock(lockPath);
+    let versions = new Set<string>();
+    for (let block of lock.blocks) {
+        if (!block.specs.some(spec => specNamePackage(spec) === packageName)) {
+            continue;
+        }
+        for (let i = block.start + 1; i < block.end; i++) {
+            let match = /^\s+version "(.*)"$/.exec(lock.lines[i]);
+            if (match) {
+                versions.add(match[1]);
+            }
+        }
+    }
+    return Array.from(versions);
+}
+
 function escapeRegExp(value: string): string {
     return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }

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 & {