build-strap 6.1.0-main.172 → 6.1.0-main.173

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "build-strap",
-  "version": "6.1.0-main.172",
+  "version": "6.1.0-main.173",
   "description": "Node scripts for building things",
   "license": "MIT",
   "author": "Justin Murray <justin@murrayju.com>",

package/src/cp.js

@@ -61,7 +61,11 @@ export async function spawn(command, args, opts) {
                 }
             };
             p.on('close', handleExit);
-            p.on('exit', handleExit);
+            // 'exit' can occur before the stdio streams are fully read. When we
+            // capture output, wait for 'close' so that no output is lost.
+            if (!captureOutput) {
+                p.on('exit', handleExit);
+            }
             // only fires if we failed to spawn
             p.on('error', (err) => {
                 // Here we have a workaround that reverses a "feature" of cross-spawn on Windows. See:

package/src/docker.container.d.ts

@@ -39,7 +39,7 @@ interface DockerContainerLsOptions {
     filter?: (container: DockerContainer) => boolean;
 }
 export declare function unthrottledDockerContainerLs({ all, filter, }?: DockerContainerLsOptions): Promise<DockerContainer[]>;
-export declare const dockerContainerLs: (options: DockerContainerLsOptions | undefined) => Promise<DockerContainer[]> | undefined;
+export declare const dockerContainerLs: typeof unthrottledDockerContainerLs;
 export declare function dockerContainerFind(search: string, options?: DockerContainerLsOptions): Promise<DockerContainer | null>;
 export declare function dockerContainerStop(id: string | string[], ignoreErrors?: boolean): Promise<void>;
 export declare function dockerContainerKill(id: string | string[], ignoreErrors?: boolean): Promise<void>;
@@ -48,7 +48,7 @@ export declare function dockerContainerRm(id: string | string[], ignoreErrors?:
 export declare function dockerContainerRestart(id: string | string[]): Promise<void>;
 export declare function dockerContainerStart(id: string | string[]): Promise<void>;
 export declare function unthrottledDockerContainerInspect(id: string | string[]): Promise<DockerContainerInspectOutput[]>;
-export declare const dockerContainerInspect: (id: string | string[]) => Promise<DockerContainerInspectOutput[]> | undefined;
+export declare const dockerContainerInspect: typeof unthrottledDockerContainerInspect;
 interface DockerContainerRunDaemonArgs {
     cmd?: string[];
     image: string;

package/src/docker.container.js

@@ -1,10 +1,7 @@
 import bytes from 'bytes';
-import { throttle } from 'lodash-es';
 import { spawn } from './cp.js';
 import { parseDockerDate } from './docker.js';
 import { buildLog, errorMessage } from './run.js';
-// calling this function in rapid succession can lead to errors.
-// prefer throttled version
 export async function unthrottledDockerContainerLs({ all, filter, } = {}) {
     return (await spawn('docker', [
         'container',
@@ -34,10 +31,10 @@ export async function unthrottledDockerContainerLs({ all, filter, } = {}) {
             exited: status.startsWith('Exited'),
             id,
             image,
-            inspect: async () => (await dockerContainerInspect(id))?.[0],
+            inspect: async () => (await dockerContainerInspect(id)).at(0),
             async isRunning() {
                 try {
-                    return (await this.inspect())?.State?.Running || false;
+                    return (await this.inspect())?.State.Running || false;
                 }
                 catch {
                     return false;
@@ -65,7 +62,10 @@ export async function unthrottledDockerContainerLs({ all, filter, } = {}) {
             status,
             stop: async (ignoreError = true) => dockerContainerStop(id, ignoreError),
             async teardown(verbose = true) {
-                const log = (msg) => verbose && buildLog(msg);
+                const log = (msg) => {
+                    if (verbose)
+                        buildLog(msg);
+                };
                 if (await this.isRunning()) {
                     try {
                         log(`Stopping container: <${this.name}>...`);
@@ -98,11 +98,10 @@ export async function unthrottledDockerContainerLs({ all, filter, } = {}) {
     })
         .filter((c) => c.id && (typeof filter === 'function' ? filter(c) : true));
 }
-export const dockerContainerLs = throttle(unthrottledDockerContainerLs, 500, {
-    trailing: false,
-});
+// The two names are the same function. Both stay exported for compatibility.
+export const dockerContainerLs = unthrottledDockerContainerLs;
 export async function dockerContainerFind(search, options) {
-    return ((await dockerContainerLs(options))?.find((c) => c.name === search ||
+    return ((await dockerContainerLs(options)).find((c) => c.name === search ||
         c.id.startsWith(search) ||
         c.names.includes(search)) || null);
 }
@@ -168,14 +167,13 @@ export async function dockerContainerStart(id) {
 }
 export async function unthrottledDockerContainerInspect(id) {
     const ids = Array.isArray(id) ? id : [id];
-    return ((await spawn('docker', ['container', 'inspect', '--format', '{{json .}}', ...ids], { captureOutput: true })).output
+    return (await spawn('docker', ['container', 'inspect', '--format', '{{json .}}', ...ids], { captureOutput: true })).output
         .split('\n')
         .filter((line) => !!line.trim())
-        .map((line) => JSON.parse(line.trim())) || []);
+        .map((line) => JSON.parse(line.trim()));
 }
-export const dockerContainerInspect = throttle(unthrottledDockerContainerInspect, 500, {
-    trailing: false,
-});
+// The two names are the same function. Both stay exported for compatibility.
+export const dockerContainerInspect = unthrottledDockerContainerInspect;
 export async function dockerContainerRun({ cmd = [], image, runArgs = [], spawnOptions, }) {
     return (await spawn('docker', ['container', 'run', ...runArgs, image, ...cmd], {
         pipeOutput: true,

package/src/docker.d.ts

@@ -5,7 +5,7 @@ export interface DockerConfig {
 }
 export declare function getDockerConfig(): DockerConfig;
 export declare const parseDockerDate: (date: string) => Date;
-export declare function dockerBuild(tags?: string[], buildArgs?: string[], target?: string | null, extraArgs?: string[], repo?: string, dockerFile?: string, workDir?: string): Promise<string>;
+export declare function dockerBuild(tags?: string[], buildArgs?: string[], target?: string | null, extraArgs?: null | string[], repo?: string, dockerFile?: string, workDir?: string): Promise<string>;
 export declare function dockerTag(imageId: string, tags?: string[], repo?: string): Promise<void>;
 /**
  * Apply the standard convention for tagging the docker image for the project,

package/src/docker.js

@@ -72,7 +72,8 @@ export async function dockerImages(repo = getDockerRepo(), filter = null) {
             tag,
         };
     })
-        .filter((m) => m?.id != null && (typeof filter === 'function' ? filter(m) : true));
+        .filter((m) => m.id != null)
+        .filter((m) => (typeof filter === 'function' ? filter(m) : true));
 }
 export async function getDockerId(tag = 'latest', repo = null) {
     return (await dockerImages(repo, (m) => m.tag === tag)).map((m) => m.id)[0];
@@ -274,7 +275,7 @@ export const ensureDockerForMacConfigured = async (desiredConfig) => {
         if (!(await fs.pathExists(configPath))) {
             throw new Error('Failed to locate the Docker config file');
         }
-        const existingConfig = await fs.readJson(configPath);
+        const existingConfig = (await fs.readJson(configPath));
         if (!Object.entries(desiredConfig).every(([key, value]) => existingConfig[key] === value)) {
             buildLog('Adjusting Docker config...');
             await fs.writeJson(configPath, {

package/src/docker.network.d.ts

@@ -13,7 +13,7 @@ interface DockerNetworkLsOptions {
     filter?: (network: DockerNetwork) => boolean;
 }
 export declare function unthrottledDockerNetworkLs({ filter, }?: DockerNetworkLsOptions): Promise<DockerNetwork[]>;
-export declare const dockerNetworkLs: (options?: DockerNetworkLsOptions) => Promise<DockerNetwork[]> | undefined;
+export declare const dockerNetworkLs: typeof unthrottledDockerNetworkLs;
 export declare function dockerNetworkFind(networkName: string, options?: DockerNetworkLsOptions): Promise<DockerNetwork | null>;
 export interface DockerNetworkCreateOptions {
     auxAddresses?: string[];

package/src/docker.network.js

@@ -1,8 +1,5 @@
-import { throttle } from 'lodash-es';
 import { spawn } from './cp.js';
 import { parseDockerDate } from './docker.js';
-// calling this function in rapid succession can lead to errors.
-// prefer throttled version
 export async function unthrottledDockerNetworkLs({ filter, } = {}) {
     return (await spawn('docker', ['network', 'ls', '--format', '{{json .}}'], {
         captureOutput: true,
@@ -25,11 +22,10 @@ export async function unthrottledDockerNetworkLs({ filter, } = {}) {
     })
         .filter((n) => n.id && (typeof filter === 'function' ? filter(n) : true));
 }
-export const dockerNetworkLs = throttle(unthrottledDockerNetworkLs, 500, {
-    trailing: false,
-});
+// The two names are the same function. Both stay exported for compatibility.
+export const dockerNetworkLs = unthrottledDockerNetworkLs;
 export async function dockerNetworkFind(networkName, options) {
-    return ((await dockerNetworkLs(options))?.find((n) => n.name === networkName || n.id === networkName) || null);
+    return ((await dockerNetworkLs(options)).find((n) => n.name === networkName || n.id === networkName) || null);
 }
 export async function dockerNetworkCreate(networkName, { auxAddresses = [], driver, driverOpts = {}, gateways = [], ingress, internal, ipRange, ipv6, labels = [], subnets = [], } = {}) {
     const existing = await dockerNetworkFind(networkName);

package/src/docker.volume.d.ts

@@ -12,7 +12,7 @@ interface DockerVolumeLsOptions {
     filter?: (vol: DockerVolume) => boolean;
 }
 export declare function unthrottledDockerVolumeLs({ filter, }?: DockerVolumeLsOptions): Promise<DockerVolume[]>;
-export declare const dockerVolumeLs: (options?: DockerVolumeLsOptions) => undefined | Promise<DockerVolume[]>;
+export declare const dockerVolumeLs: typeof unthrottledDockerVolumeLs;
 export declare function dockerVolumeFind(search: string, options?: DockerVolumeLsOptions): Promise<null | DockerVolume>;
 export interface DockerVolumeCreateOptions {
     driver?: string;
@@ -22,5 +22,5 @@ export interface DockerVolumeCreateOptions {
 export declare function dockerVolumeCreate(name: string, { driver, driverOpts, labels }?: DockerVolumeCreateOptions): Promise<null | DockerVolume>;
 export declare function dockerVolumeRm(id: string | string[], ignoreErrors?: boolean): Promise<void>;
 export declare function unthrottledDockerVolumeInspect(id: string | string[]): Promise<DockerVolumeInspectOutput[]>;
-export declare const dockerVolumeInspect: (id: string | string[]) => undefined | Promise<DockerVolumeInspectOutput[]>;
+export declare const dockerVolumeInspect: typeof unthrottledDockerVolumeInspect;
 export {};

package/src/docker.volume.js

@@ -1,8 +1,5 @@
-import { throttle } from 'lodash-es';
 import { spawn } from './cp.js';
 import { errorMessage } from './run.js';
-// calling this function in rapid succession can lead to errors.
-// prefer throttled version
 export async function unthrottledDockerVolumeLs({ filter, } = {}) {
     return (await spawn('docker', ['volume', 'ls', '--format', '{{json .}}'], {
         captureOutput: true,
@@ -13,7 +10,7 @@ export async function unthrottledDockerVolumeLs({ filter, } = {}) {
         const { Driver: driver, Labels, Mountpoint: mountPoint, Name: name, Scope: scope, } = JSON.parse(line.trim());
         return {
             driver,
-            inspect: async () => (await dockerVolumeInspect(name))?.[0] || null,
+            inspect: async () => (await dockerVolumeInspect(name)).at(0) || null,
             labels: Labels.split(',').map((l) => l.trim()),
             mountPoint,
             name,
@@ -23,11 +20,10 @@ export async function unthrottledDockerVolumeLs({ filter, } = {}) {
     })
         .filter((v) => v.name && (typeof filter === 'function' ? filter(v) : true));
 }
-export const dockerVolumeLs = throttle(unthrottledDockerVolumeLs, 500, {
-    trailing: false,
-});
+// The two names are the same function. Both stay exported for compatibility.
+export const dockerVolumeLs = unthrottledDockerVolumeLs;
 export async function dockerVolumeFind(search, options) {
-    return ((await dockerVolumeLs(options))?.find((v) => v.name === search || v.name.startsWith(search)) ?? null);
+    return ((await dockerVolumeLs(options)).find((v) => v.name === search || v.name.startsWith(search)) ?? null);
 }
 export async function dockerVolumeCreate(name, { driver, driverOpts = {}, labels = [] } = {}) {
     const existing = await dockerVolumeFind(name);
@@ -56,10 +52,13 @@ export async function dockerVolumeRm(id, ignoreErrors = true) {
         }
     }
 }
-// calling this function in rapid succession can lead to errors.
-// prefer throttled version
 export async function unthrottledDockerVolumeInspect(id) {
     const ids = Array.isArray(id) ? id : [id];
-    return (JSON.parse((await spawn('docker', ['volume', 'inspect', '--format', '{{json .}}', ...ids], { captureOutput: true })).output.trim()) || []);
+    // With --format, docker writes one JSON object per line, not an array
+    return (await spawn('docker', ['volume', 'inspect', '--format', '{{json .}}', ...ids], { captureOutput: true })).output
+        .split('\n')
+        .filter((line) => !!line.trim())
+        .map((line) => JSON.parse(line.trim()));
 }
-export const dockerVolumeInspect = throttle(unthrottledDockerVolumeInspect, 500, { trailing: true });
+// The two names are the same function. Both stay exported for compatibility.
+export const dockerVolumeInspect = unthrottledDockerVolumeInspect;

package/src/dockerCleanup.js

@@ -12,9 +12,7 @@ import { buildLog } from './run.js';
 async function flatten(input) {
     const result = await input;
     return Array.isArray(result)
-        ? [].concat(
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        ...(await Promise.all(result.map(flatten))))
+        ? [].concat(...(await Promise.all(result.map(flatten))))
         : result;
 }
 /**
@@ -26,7 +24,7 @@ export const dockerContainerCleanup = async ({ dryRun = process.argv.includes('-
         filter: (c) => c.exited,
     });
     if (dryRun) {
-        if (toClean) {
+        if (toClean.length) {
             buildLog(`Containers to delete (dry run):\n  ${toClean
                 .map((c) => c.id)
                 .join('\n  ')}`);
@@ -35,7 +33,7 @@ export const dockerContainerCleanup = async ({ dryRun = process.argv.includes('-
             buildLog('No containers to delete (dry run)');
         }
     }
-    else if (toClean) {
+    else {
         await Promise.all(toClean.map(async (c) => c.rm(true)));
     }
 };

package/src/dockerCompose.d.ts

@@ -33,10 +33,10 @@ interface DockerComposeNetworkDef extends DockerNetworkCreateOptions {
     name?: string;
 }
 interface DockerCompose {
-    networks?: Record<string, DockerComposeNetworkDef>;
+    networks?: Record<string, null | DockerComposeNetworkDef>;
     services?: Record<string, DockerComposeServiceDef>;
     version: string;
-    volumes?: Record<string, DockerComposeVolumeDef>;
+    volumes?: Record<string, null | DockerComposeVolumeDef>;
 }
 /**
  * Parse a docker-compose.yml file into a pojo representation

package/src/dockerCompose.js

@@ -84,7 +84,7 @@ const parseVolumes = async (volCfg = [], nameSuffix = '', dockerCompose = null)
 };
 const parseNetworks = async (netCfg = [], dockerCompose = null) => {
     const { networks: netMap } = await dockerComposeResolve(dockerCompose);
-    const networks = netCfg.map((n) => netMap?.[n].name || prefixName(n));
+    const networks = netCfg.map((n) => netMap?.[n]?.name || prefixName(n));
     return {
         networks,
         runArgs: networks.flatMap((n) => ['--network', n]),
@@ -95,7 +95,7 @@ export const dockerComposeCreateNetworks = async (names, dockerCompose, tracker
     await Promise.all(Object.entries(networks).map(async ([key, val]) => {
         const name = val?.name || prefixName(key);
         if (names?.includes(name)) {
-            const network = await dockerNetworkCreate(name, val);
+            const network = await dockerNetworkCreate(name, val ?? undefined);
             if (network) {
                 tracker.networks.set(name, network);
             }
@@ -107,7 +107,7 @@ export const dockerComposeCreateVolumes = async (names, dockerCompose, tracker =
     await Promise.all(Object.entries(volumes).map(async ([key, val]) => {
         const name = val?.name || prefixName(key);
         if (!names || names.includes(name)) {
-            const volume = await dockerVolumeCreate(name, val);
+            const volume = await dockerVolumeCreate(name, val ?? undefined);
             if (volume) {
                 tracker.volumes.set(name, volume);
             }
@@ -413,7 +413,10 @@ export async function dockerComposeRunService(key, upOptions = {}, dockerCompose
     const upResult = await service.up(upOptions);
     const { container, ports: [{ docker: dockerPort, local: port }], urls, urls: [{ docker: dockerUrl, local: url }], } = upResult;
     const { id, image, name } = container;
-    urls.forEach(({ local }) => local && buildLog(`<${service.name}> accessible at ${local}`));
+    urls.forEach(({ local }) => {
+        if (local)
+            buildLog(`<${service.name}> accessible at ${local}`);
+    });
     return {
         ...upResult,
         dockerPort,

package/src/maps.js

@@ -38,6 +38,4 @@ export const filterKeys = (obj, filter = (v) => v != null) => Object.entries(obj
  * @param {Object} obj the input object
  * @returns {Object} a new object, a subset of the input
  */
-export const filterNullish = (obj) => 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-filterKeys(obj);
+export const filterNullish = (obj) => filterKeys(obj);

package/src/npm.js

@@ -8,7 +8,9 @@ import { getDefaultNpmDistTag, getVersion } from './version.js';
 export function getNpmConfig() {
     return getCfg().npm || {};
 }
-export const envNpmCreds = (process.env.NPM_CREDS && JSON.parse(process.env.NPM_CREDS)) || null;
+export const envNpmCreds = (process.env.NPM_CREDS &&
+    JSON.parse(process.env.NPM_CREDS)) ||
+    null;
 const npmExe = (npmPath) => npmPath || (platform() === 'win32' ? 'npm.cmd' : 'npm');
 export async function npm({ args = [], npmPath, spawnOptions, } = {}) {
     // The node distribution puts npm next to the node binary.

package/src/orbstack.js

@@ -60,7 +60,7 @@ export const ensureOrbStackConfigured = async (desiredConfig) => {
         changed = true;
     }
     else {
-        const existingConfig = await fs.readJson(configPath);
+        const existingConfig = (await fs.readJson(configPath));
         const effectiveConfig = {
             ...defaultConfig,
             ...existingConfig,

package/src/pkg.d.ts

@@ -16,7 +16,7 @@ export interface Person {
 }
 export interface PackageJson {
     author?: string | Person;
-    buildStrap: BuildStrapConfig;
+    buildStrap?: BuildStrapConfig;
     contributors?: (string | Person)[];
     dependencies?: Record<string, string>;
     description?: string;

package/src/pkg.js

@@ -15,7 +15,7 @@ export function setPkg(p) {
 const pkgNameRegex = /^(?:(@[^/]+)\/)?(.+)$/i;
 export function getPkgName(includeScope = false) {
     const pkg = getPkg();
-    if (!(pkg.name && pkg.name.length)) {
+    if (!pkg.name) {
         throw new Error('Package name not found in package.json, but this is a required property!');
     }
     if (includeScope) {
@@ -38,6 +38,7 @@ export function getPkgSafeName() {
         return null;
     }
     const [, scope, name] = match;
+    // the scope group is optional, so it can be undefined at runtime
     const safeScope = scope?.slice(1);
     return safeScope ? `${safeScope}-${name}` : name;
 }

package/src/run.js

@@ -17,6 +17,9 @@ export function errorMessage(err) {
         return err;
     }
     try {
+        // JSON.stringify returns undefined for undefined, functions and symbols,
+        // but the TypeScript lib types declare the return type as string only
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
         return JSON.stringify(err) ?? String(err);
     }
     catch {
@@ -60,6 +63,8 @@ export function buildLog(msg, timeOrOptions) {
     writeLog(`[${format(time || new Date())}] ${msg}`, stream);
 }
 export async function run(fn, ...options) {
+    // JavaScript callers can pass null or undefined
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
     if (fn == null) {
         throw new Error(`Invalid argument passed to run(${String(fn)})`);
     }