@servicetitan/startup 36.1.1 → 36.1.2-canary.2

package/src/scripts/__tests__/generate-bin-wrappers.test.ts

@@ -0,0 +1,226 @@
+import fs from 'fs';
+import { vol } from 'memfs';
+import path from 'path';
+
+jest.mock('fs', () => require('memfs').fs);
+
+const { main } = require('../generate-bin-wrappers');
+
+/*
+ * Use the real startup directory so path.resolve(__dirname, '..') in the
+ * module resolves naturally. The memfs volume mirrors the real directory
+ * layout - no path.resolve mock needed.
+ */
+const startupDir = path.resolve(__dirname, '..', '..', '..');
+const binDir = path.join(startupDir, 'bin');
+const nodeModulesDir = path.join(startupDir, 'node_modules');
+const startupPackageJson = path.join(startupDir, 'package.json');
+
+describe('[startup] generate-bin-wrappers', () => {
+    const defaultBin = { startup: './bin/index.js' };
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+        jest.spyOn(console, 'log').mockImplementation(() => {});
+    });
+
+    afterEach(() => {
+        vol.reset();
+        jest.restoreAllMocks();
+    });
+
+    describe(main.name, () => {
+        const pkgScriptName = 'foo';
+        const pkgScriptPath = './bin/cli.js';
+        const pkg = { name: 'bar', version: '1.0.0', bin: { [pkgScriptName]: pkgScriptPath } };
+        const pkgJsonPath = path.join(nodeModulesDir, pkg.name, 'package.json');
+        const wrapper = path.join(binDir, `${pkgScriptName}.js`);
+
+        function volFromJSON(overrides: Record<string, string | Record<string, any>> = {}) {
+            vol.fromJSON({
+                [startupPackageJson]: JSON.stringify({
+                    dependencies: { [pkg.name]: pkg.version },
+                    bin: defaultBin,
+                }),
+                [pkgJsonPath]: JSON.stringify(pkg),
+                ...Object.fromEntries(
+                    Object.entries(overrides).map(([k, v]) => [
+                        k,
+                        typeof v === 'string' ? v : JSON.stringify(v),
+                    ])
+                ),
+            });
+        }
+
+        beforeEach(() => {
+            volFromJSON();
+            fs.mkdirSync(binDir, { recursive: true });
+        });
+
+        const subject = () => main();
+
+        test('generates executable script', () => {
+            subject();
+
+            expect(fs.statSync(wrapper).mode & 0o755).toBe(0o755);
+            expect(fs.readFileSync(wrapper, 'utf8')).toContain(
+                `require('./_run')('${pkg.name}', '${pkgScriptPath}')`
+            );
+        });
+
+        test('adds script to package.json bin field', () => {
+            subject();
+
+            expect(JSON.parse(fs.readFileSync(startupPackageJson, 'utf8')).bin).toEqual(
+                expect.objectContaining({
+                    [pkgScriptName]: `./bin/${pkgScriptName}.js`,
+                    ...defaultBin,
+                })
+            );
+        });
+
+        describe('with string-form bin field', () => {
+            beforeEach(() => {
+                volFromJSON({ [pkgJsonPath]: { name: pkg.name, bin: './cli.js' } });
+            });
+
+            test('uses package name as script name', () => {
+                subject();
+
+                expect(fs.existsSync(path.join(binDir, `${pkg.name}.js`))).toBe(true);
+            });
+
+            describe('with scoped package', () => {
+                const scoped = { name: `@scope/${pkg.name}`, bin: './cli.js' };
+
+                beforeEach(() => volFromJSON({ [pkgJsonPath]: scoped }));
+
+                test('omits scope from script name', () => {
+                    subject();
+
+                    expect(fs.existsSync(path.join(binDir, `${pkg.name}.js`))).toBe(true);
+                });
+            });
+        });
+
+        function itDoesNotGenerateWrapper() {
+            test('does not generate wrapper', () => {
+                subject();
+
+                expect(fs.existsSync(wrapper)).toBe(false);
+            });
+        }
+
+        describe.each(['@servicetitan/install'])('when dependency is %s', name => {
+            beforeEach(() => {
+                volFromJSON({
+                    [startupPackageJson]: { dependencies: { [name]: '1.0.0' } },
+                    [path.join(nodeModulesDir, name, 'package.json')]: { ...pkg, name },
+                });
+            });
+
+            itDoesNotGenerateWrapper();
+        });
+
+        describe('with no dependencies', () => {
+            beforeEach(() => {
+                volFromJSON({ [startupPackageJson]: {} });
+            });
+
+            test('does nothing', () => {
+                expect(() => subject()).not.toThrow();
+            });
+        });
+
+        describe('when dependency has no bin field', () => {
+            beforeEach(() => {
+                fs.writeFileSync(pkgJsonPath, JSON.stringify({ name: pkg.name }));
+            });
+
+            itDoesNotGenerateWrapper();
+        });
+
+        describe('when dependency package.json does not exist', () => {
+            beforeEach(() => {
+                fs.rmSync(path.join(nodeModulesDir, pkg.name), { recursive: true });
+            });
+
+            itDoesNotGenerateWrapper();
+        });
+
+        describe('when wrapper already exists with same content', () => {
+            beforeEach(() => {
+                subject();
+            });
+
+            test('does not rewrite wrapped', () => {
+                const writeFileSpy = jest.spyOn(fs, 'writeFileSync');
+                subject();
+
+                expect(
+                    writeFileSpy.mock.calls.filter(([path]) => String(path) === wrapper)
+                ).toHaveLength(0);
+            });
+
+            test('does not rewrite package.json', () => {
+                const writeFileSpy = jest.spyOn(fs, 'writeFileSync');
+                subject();
+
+                expect(
+                    writeFileSpy.mock.calls.filter(([path]) => String(path) === startupPackageJson)
+                ).toHaveLength(0);
+            });
+        });
+
+        describe('when obsolete wrapper exists', () => {
+            const obsoleteWrapper = path.join(binDir, 'old-tool.js');
+
+            beforeEach(() => {
+                volFromJSON({
+                    [obsoleteWrapper]: '// Auto-generated by scripts/generate-bin-wrappers.js\n',
+                });
+            });
+
+            test('removes it', () => {
+                subject();
+
+                expect(fs.existsSync(obsoleteWrapper)).toBe(false);
+            });
+
+            describe('when remove fails', () => {
+                beforeEach(() => {
+                    jest.spyOn(fs, 'rmSync').mockImplementation(() => {
+                        throw new Error('Oops!');
+                    });
+                });
+
+                test('ignores it', () => {
+                    expect(() => subject()).not.toThrow();
+                });
+            });
+        });
+
+        describe('with real dependency resolved via require.resolve', () => {
+            const realPkg = { name: 'patch-package', version: '1.0.0', bin: './index.js' };
+            const realPkgJson = require.resolve(path.join(realPkg.name, 'package.json'), {
+                paths: [startupDir],
+            });
+
+            beforeEach(() => {
+                volFromJSON({
+                    [startupPackageJson]: { dependencies: { [realPkg.name]: realPkg.version } },
+                    [realPkgJson]: { name: realPkg.name, bin: realPkg.bin },
+                });
+            });
+
+            test('generates wrapper from resolved package.json', () => {
+                subject();
+
+                const wrapper = path.join(binDir, `${realPkg.name}.js`);
+                expect(fs.readFileSync(wrapper, 'utf8')).toContain(
+                    `require('./_run')('${realPkg.name}', '${realPkg.bin}')`
+                );
+            });
+        });
+    });
+});

package/src/scripts/generate-bin-wrappers.js

@@ -0,0 +1,205 @@
+#!/usr/bin/env node
+/* eslint-disable no-console */
+
+/**
+ * Generates bin wrapper scripts for all CLI tools exposed by startup's dependencies.
+ *
+ * pnpm uses strict node_modules isolation - only direct dependencies' bins are linked
+ * into a consumer's node_modules/.bin/. Since startup acts as a toolbox package, it
+ * needs to re-export its dependencies' bins so consumers get them automatically.
+ *
+ * Under npm these wrappers are harmless but redundant - npm links the original
+ * package's bins directly. Under pnpm, startup's wrappers are the only ones
+ * visible to consumers.
+ *
+ * This script:
+ * 1. Reads startup's dependencies from package.json
+ * 2. Resolves each dependency's `bin` entries
+ * 3. Generates thin wrapper scripts in bin/ (using shared bin/_run.js helper)
+ * 4. Removes obsolete wrappers from previous runs
+ * 5. Updates the `bin` field in startup's package.json
+ *
+ * Run: npm run prepare -w packages/startup
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const GENERATED_MARKER = 'Auto-generated by scripts/generate-bin-wrappers.js';
+
+// Packages whose bins should not be exposed to consumers
+const SKIP_PACKAGES = new Set([
+    '@servicetitan/install', // consumers use @servicetitan/install directly
+]);
+
+// Bins from transitive dependencies that startup needs to expose to consumers
+const EXTRA_BINS = [
+    {
+        name: 'kendo-ui-license',
+        from: '@progress/kendo-licensing',
+        binPath: 'bin/kendo-ui-license.js',
+    },
+];
+
+/*
+ * Collect bin entries from each dependency's package.json. Skips packages in
+ * SKIP_PACKAGES, normalizes string-form bin fields to { name: path } objects,
+ * and appends EXTRA_BINS for transitive dependencies that need explicit exposure.
+ */
+function discoverBins(startupDirectory, dependencies) {
+    const bins = [];
+
+    for (const packageName of dependencies) {
+        if (SKIP_PACKAGES.has(packageName)) {
+            continue;
+        }
+        let packageJson;
+        try {
+            const packageJsonPath = require.resolve(packageName + '/package.json', {
+                paths: [startupDirectory],
+            });
+            packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+        } catch {
+            // Some packages block ./package.json in exports - read directly from node_modules
+            try {
+                const packageJsonPath = resolveNodeModulesPackageJson(
+                    packageName,
+                    startupDirectory
+                );
+                packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+            } catch {
+                continue;
+            }
+        }
+
+        if (!packageJson.bin) {
+            continue;
+        }
+
+        /*
+         * When bin is a string the command name defaults to the package name.
+         * Strip the @scope/ prefix for scoped packages, matching npm's behavior.
+         */
+        const entries =
+            typeof packageJson.bin === 'string'
+                ? { [packageJson.name.replace(/^@.*\//, '')]: packageJson.bin }
+                : packageJson.bin;
+
+        for (const [name, binPath] of Object.entries(entries)) {
+            bins.push({ name, from: packageName, binPath });
+        }
+    }
+
+    bins.push(...EXTRA_BINS);
+    bins.sort((a, b) => a.name.localeCompare(b.name));
+    return bins;
+}
+
+/*
+ * Delete previously generated wrappers that no longer correspond to a
+ * dependency. Identifies generated files by the presence of GENERATED_MARKER
+ * and removes any that aren't in the current bin list.
+ */
+function removeObsoleteWrappers(binDirectory, bins) {
+    const generatedNames = new Set(bins.map(bin => `${bin.name}.js`));
+    const removed = [];
+    for (const file of fs.readdirSync(binDirectory)) {
+        const filePath = path.join(binDirectory, file);
+        try {
+            const content = fs.readFileSync(filePath, 'utf8');
+            if (content.includes(GENERATED_MARKER) && !generatedNames.has(file)) {
+                fs.rmSync(filePath);
+                removed.push(file);
+            }
+        } catch {
+            continue;
+        }
+    }
+    return removed;
+}
+
+/*
+ * Write a thin wrapper script for each bin entry. Each wrapper delegates to
+ * bin/_run.js which locates and executes the real binary. Skips files whose
+ * content is already up to date. Returns the bin entries for package.json
+ * and the list of wrappers that were added or updated.
+ */
+function generateWrappers(binDirectory, bins) {
+    const binEntries = {
+        startup: './bin/index.js',
+    };
+    const added = [];
+
+    for (const { name, from, binPath } of bins) {
+        const wrapperPath = path.join(binDirectory, `${name}.js`);
+        const wrapper = `#!/usr/bin/env node
+// ${GENERATED_MARKER} - wraps: ${from} -> ${binPath}
+require('./_run')('${from}', '${binPath}');
+`;
+        const existing = fs.existsSync(wrapperPath) && fs.readFileSync(wrapperPath, 'utf8');
+        const normalized = existing && existing.replace(/\r\n/g, '\n');
+        if (normalized !== wrapper) {
+            fs.writeFileSync(wrapperPath, wrapper);
+            fs.chmodSync(wrapperPath, 0o755);
+            added.push(name);
+        }
+        binEntries[name] = `./bin/${name}.js`;
+    }
+
+    return { binEntries, added };
+}
+
+/**
+ * Walk up node_modules directories to find a dependency's package.json,
+ * handling both hoisted and nested layouts.
+ */
+function resolveNodeModulesPackageJson(packageName, fromDirectory) {
+    let directory = fromDirectory;
+    while (directory !== path.dirname(directory)) {
+        const candidate = path.join(directory, 'node_modules', packageName, 'package.json');
+        if (fs.existsSync(candidate)) {
+            return candidate;
+        }
+        directory = path.dirname(directory);
+    }
+    throw new Error(`Cannot find package.json for ${packageName}`);
+}
+
+function main() {
+    const startupDirectory = path.resolve(__dirname, '..', '..');
+    const packageJsonPath = path.join(startupDirectory, 'package.json');
+    const binDirectory = path.join(startupDirectory, 'bin');
+
+    console.log('Generating bin wrappers...');
+
+    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+    const dependencies = Object.keys(packageJson.dependencies ?? {});
+
+    const bins = discoverBins(startupDirectory, dependencies);
+    const removed = removeObsoleteWrappers(binDirectory, bins);
+    const { binEntries, added } = generateWrappers(binDirectory, bins);
+
+    if (JSON.stringify(packageJson.bin) !== JSON.stringify(binEntries)) {
+        packageJson.bin = binEntries;
+        fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 4) + '\n');
+    }
+
+    for (const name of added) {
+        console.log(`  added: ${name}`);
+    }
+    for (const file of removed) {
+        console.log(`  removed: ${file}`);
+    }
+    const upToDate = bins.length - added.length;
+    console.log(
+        `  ${added.length} added/updated, ${removed.length} removed, ${upToDate} up to date`
+    );
+}
+
+// Only run when executed directly (e.g., `node generate-bin-wrappers.js`), not when imported (e.g., in tests).
+/* istanbul ignore next */
+if (require.main === module) {
+    main();
+}
+
+module.exports = { main };

package/src/storybook-config/__tests__/webpack-final.test.ts

@@ -49,31 +49,6 @@ describe(`[startup/storybook-config] ${webpackFinal.name}`, () => {
         );
     });
 
-    describe('when config has optimization settings', () => {
-        beforeEach(() => {
-            config.optimization = { sideEffects: true, splitChunks: { chunks: 'all' } };
-        });
-
-        describe('when mode is development', () => {
-            beforeEach(() => (config.mode = 'development'));
-
-            test('disables sideEffects to preserve CSS imports from barrel files', () => {
-                expect(subject().optimization).toEqual({
-                    ...config.optimization,
-                    sideEffects: false,
-                });
-            });
-        });
-
-        describe('when mode is production', () => {
-            beforeEach(() => (config.mode = 'production'));
-
-            test('does not change sideEffects', () => {
-                expect(subject().optimization).toEqual(config.optimization);
-            });
-        });
-    });
-
     test('adds MiniCssExtractPlugin to config', () => {
         expect(subject().plugins).toEqual([mockMiniCssExtractPlugin]);
     });

package/src/storybook-config/webpack-final.ts

@@ -14,10 +14,6 @@ export function webpackFinal(config: Configuration, overrides: Overrides = {}):
 
     return {
         ...config,
-        optimization: {
-            ...config.optimization,
-            ...(config.mode !== 'production' ? { sideEffects: false } : {}),
-        },
         module: {
             ...config.module,
             rules: [...transformDefaultRules(config.module?.rules), ...rules],

package/src/utils/__tests__/get-jest-config.test.ts

@@ -27,7 +27,9 @@ describe('[startup] Utils', () => {
         testEnvironment: 'jsdom',
         testPathIgnorePatterns: ['\\.yalc', ...destinationFolders],
         testRunner: 'jest-circus/runner',
-        transformIgnorePatterns: ['node_modules/(?!(@servicetitan|@react-hook|nanoid|axios)/)'],
+        transformIgnorePatterns: [
+            'node_modules/(?!.*node_modules/)(?!(@servicetitan|@react-hook|nanoid|axios)/)',
+        ],
         verbose: true,
     };
 

package/src/utils/__tests__/get-packages.test.ts

@@ -190,10 +190,55 @@ describe('[startup] Utils', () => {
             });
         }
 
-        describe('with no packages', () => {
-            beforeEach(() => vol.fromJSON({ 'package.json': JSON.stringify({}) }));
+        describe('when package.json omits packages', () => {
+            const packages = {
+                foo: {
+                    'package.json': JSON.stringify({
+                        name: 'foo',
+                        version: '1.0.0',
+                    }),
+                },
+            };
+
+            function volFromJSON(json?: Record<string, any>) {
+                vol.fromNestedJSON({
+                    'package.json': JSON.stringify({}),
+                    packages,
+                    ...json,
+                });
+            }
+
+            beforeEach(() => volFromJSON());
 
             itReturnsEmptyArray();
+
+            function itReturnsPackages() {
+                test('returns packages', () => {
+                    expect(subject()).toEqual([
+                        expect.objectContaining({ name: 'foo', version: '1.0.0' }),
+                    ]);
+                });
+            }
+
+            describe('when pnpm-workspace.yaml contains packages', () => {
+                beforeEach(() => {
+                    volFromJSON({
+                        'pnpm-workspace.yaml': 'packages:\n  - "packages/*"\n',
+                    });
+                });
+
+                itReturnsPackages();
+            });
+
+            describe('with lerna.json contains packages', () => {
+                beforeEach(() => {
+                    volFromJSON({
+                        'lerna.json': JSON.stringify({ packages: ['packages/*'] }),
+                    });
+                });
+
+                itReturnsPackages();
+            });
         });
 
         describe('with no package.json', () => {

package/src/utils/__tests__/prettify.test.ts

@@ -8,7 +8,7 @@ jest.mock('node:child_process', () => ({
 
 describe('[startup] Prettify Utils', () => {
     const filename = '/path/to/file.ts';
-    const expectedCommand = `npx prettier -w "${filename}"`;
+    const expectedCommand = `prettier -w "${filename}"`;
 
     beforeEach(() => {
         jest.resetAllMocks();

package/src/utils/find-packages.ts

@@ -1,4 +1,6 @@
+import fs from 'fs';
 import { globSync } from 'glob';
+import yaml from 'js-yaml';
 import multimatch from 'multimatch';
 import path from 'path';
 import { findUp } from './find-up';
@@ -44,6 +46,12 @@ function findWorkspaces() {
         log.debug('find-packages', `reading: ${packageJson}`);
         let workspaces = readJsonSafe<{ workspaces: string[] }>(packageJson)?.workspaces;
 
+        if (!workspaces) {
+            const pnpmWorkspace = path.resolve(path.join(directory, 'pnpm-workspace.yaml'));
+            log.debug('find-packages', `reading: ${pnpmWorkspace}`);
+            workspaces = readYamlSafe<{ packages: string[] }>(pnpmWorkspace)?.packages;
+        }
+
         if (!workspaces) {
             const lernaJson = path.resolve(path.join(directory, 'lerna.json'));
             log.debug('find-packages', `reading: ${lernaJson}`);
@@ -64,3 +72,11 @@ function findWorkspaces() {
         }
     });
 }
+
+function readYamlSafe<T>(filePath: string): T | undefined {
+    try {
+        return yaml.load(fs.readFileSync(filePath, 'utf-8')) as T;
+    } catch {
+        return undefined;
+    }
+}

package/src/utils/get-jest-config.ts

@@ -22,7 +22,10 @@ function getDefaultJestConfiguration() {
         testEnvironment: 'jsdom',
         testPathIgnorePatterns: ['\\.yalc', ...getDestinationFolders()],
         testRunner: 'jest-circus/runner',
-        transformIgnorePatterns: ['node_modules/(?!(@servicetitan|@react-hook|nanoid|axios)/)'],
+        // Under pnpm, dependencies are nested (e.g. node_modules/.pnpm/…/node_modules/pkg); the extra lookahead skips the inner node_modules.
+        transformIgnorePatterns: [
+            'node_modules/(?!.*node_modules/)(?!(@servicetitan|@react-hook|nanoid|axios)/)',
+        ],
         verbose: true,
     } as Omit<Config.Argv, 'collectCoverageFrom' | 'moduleNameMapper' | 'setupFiles'> & {
         collectCoverageFrom: string[];

package/src/utils/prettify.ts

@@ -2,7 +2,7 @@ import { exec, execSync } from 'node:child_process';
 import { promisify } from 'node:util';
 
 function getCommand(filename: string) {
-    return `npx prettier -w "${filename}"`;
+    return `prettier -w "${filename}"`;
 }
 
 function createError(exitCode: number) {

package/src/webpack/configs/cache-config.ts

@@ -1,3 +1,4 @@
+import { getPackageManager } from '@servicetitan/install';
 import fs from 'fs';
 import path from 'path';
 import { Configuration } from 'webpack';
@@ -30,8 +31,9 @@ export function cacheConfig(context: Context, _overrides: Overrides): Result {
 }
 
 function findPackageLock() {
+    const { lockFileName } = getPackageManager();
     return findUp(directory => {
-        const lockFile = path.resolve(path.join(directory), 'package-lock.json');
+        const lockFile = path.resolve(path.join(directory), lockFileName);
         return fs.existsSync(lockFile) ? lockFile : undefined;
     });
 }