@neurodevs/ndx-cli 0.1.32 → 0.1.33

package/src/__tests__/modules/CliCommandRunner.test.ts

@@ -45,11 +45,18 @@ export default class CliCommandRunnerTest extends AbstractPackageTest {
     private static readonly packageName = generateId()
     private static readonly description = generateId()
     private static readonly keywords = [generateId(), generateId()]
+    private static readonly githubToken = generateId()
+
+    private static readonly defaultKeywords = ['nodejs', 'typescript', 'tdd']
+
+    private static get keywordsWithDefaults() {
+        return [...this.defaultKeywords, ...this.keywords]
+    }
 
     private static readonly createUiCommand = 'create.ui'
     private static readonly componentName = generateId()
 
-    private static readonly githubToken = generateId()
+    private static readonly upgradePackageCommand = 'upgrade.package'
 
     protected static async beforeEach() {
         await super.beforeEach()
@@ -257,7 +264,7 @@ export default class CliCommandRunnerTest extends AbstractPackageTest {
             {
                 name: this.packageName,
                 description: this.description,
-                keywords: this.keywordsWithDefaults(),
+                keywords: this.keywordsWithDefaults,
                 gitNamespace: 'neurodevs',
                 npmNamespace: 'neurodevs',
                 installDir: this.expandHomeDir('~/dev'),
@@ -268,10 +275,6 @@ export default class CliCommandRunnerTest extends AbstractPackageTest {
         )
     }
 
-    private static keywordsWithDefaults() {
-        return ['nodejs', 'typescript', 'tdd', ...this.keywords]
-    }
-
     @test()
     protected static async createPackageRunsNpmAutopackage() {
         await this.runCreatePackage()
@@ -279,7 +282,7 @@ export default class CliCommandRunnerTest extends AbstractPackageTest {
         assert.isEqual(
             FakeAutopackage.numCallsToRun,
             1,
-            'Did not call run on Autopackage!'
+            'Did not call run on NpmAutopackage!'
         )
     }
 
@@ -549,6 +552,100 @@ export default class CliCommandRunnerTest extends AbstractPackageTest {
         )
     }
 
+    @test()
+    protected static async upgradePackageCreatesInstance() {
+        const instance = await this.runUpgradePackage()
+
+        assert.isTruthy(
+            instance,
+            `Failed to create instance for ${this.upgradePackageCommand}!`
+        )
+    }
+
+    @test()
+    protected static async upgradePackageCreatesNpmAutopackage() {
+        const infoFromPackageJson = {
+            name: this.packageName,
+            description: this.description,
+            keywords: this.keywordsWithDefaults,
+        }
+
+        setFakeReadFileResult(
+            'package.json',
+            JSON.stringify(infoFromPackageJson)
+        )
+
+        await this.runUpgradePackage()
+
+        assert.isEqualDeep(
+            FakeAutopackage.callsToConstructor[0],
+            {
+                ...infoFromPackageJson,
+                gitNamespace: 'neurodevs',
+                npmNamespace: 'neurodevs',
+                installDir: this.expandHomeDir('~/dev'),
+                license: 'MIT',
+                author: 'Eric Yates <hello@ericthecurious.com>',
+            },
+            'Did not create NpmAutopackage with expected options!'
+        )
+    }
+
+    @test()
+    protected static async upgradePackageRunsNpmAutopackage() {
+        await this.runUpgradePackage()
+
+        assert.isEqual(
+            FakeAutopackage.numCallsToRun,
+            1,
+            'Did not call run on NpmAutopackage!'
+        )
+    }
+
+    @test()
+    protected static async upgradePackageAddsDefaultKeywordsIfMissing() {
+        const infoFromPackageJson = {
+            name: this.packageName,
+            description: this.description,
+            keywords: [],
+        }
+
+        setFakeReadFileResult(
+            'package.json',
+            JSON.stringify(infoFromPackageJson)
+        )
+
+        await this.runUpgradePackage()
+
+        assert.isEqualDeep(
+            FakeAutopackage.callsToConstructor[0]?.keywords,
+            this.defaultKeywords,
+            'Did not add default keywords!'
+        )
+    }
+
+    @test()
+    protected static async upgradePackageDoesNotOverwriteKeywordsEvenIfDefaultsAreMissing() {
+        const infoFromPackageJson = {
+            name: this.packageName,
+            description: this.description,
+            keywords: [generateId(), generateId()],
+        }
+
+        setFakeReadFileResult(
+            'package.json',
+            JSON.stringify(infoFromPackageJson)
+        )
+
+        await this.runUpgradePackage()
+
+        assert.isEqualDeep(
+            FakeAutopackage.callsToConstructor[0]?.keywords,
+            [...this.defaultKeywords, ...infoFromPackageJson.keywords],
+            'Should not have overwritten keywords!'
+        )
+    }
+
     private static async runCreateUi(
         responses?: Record<string, string | boolean>
     ) {
@@ -645,6 +742,13 @@ export default class CliCommandRunnerTest extends AbstractPackageTest {
         return instance
     }
 
+    private static async runUpgradePackage() {
+        const instance = this.CliCommandRunner([this.upgradePackageCommand])
+        await instance.run()
+
+        return instance
+    }
+
     private static expandHomeDir(inputPath: string): string {
         return inputPath.startsWith('~')
             ? path.join(os.homedir(), inputPath.slice(1))

package/src/modules/CliCommandRunner.ts

@@ -1,14 +1,11 @@
 import { exec as execSync } from 'child_process'
 import { mkdir, readFile, writeFile } from 'fs/promises'
-import os from 'os'
-import path from 'path'
 import { promisify } from 'util'
-import {
-    ImplAutomodule,
-    NpmAutopackage,
-    UiAutomodule,
-} from '@neurodevs/meta-node'
 import prompts from 'prompts'
+import CreateImplCommand from './commands/CreateImplCommand'
+import CreatePackageCommand from './commands/CreatePackageCommand'
+import CreateUiCommand from './commands/CreateUiCommand'
+import UpgradePackageCommand from './commands/UpgradePackageCommand'
 
 export default class CliCommandRunner implements CommandRunner {
     public static Class?: CommandRunnerConstructor
@@ -21,21 +18,15 @@ export default class CliCommandRunner implements CommandRunner {
     private args: string[]
 
     private readonly createImplCommand = 'create.impl'
-    private interfaceName!: string
-    private implName!: string
-
     private readonly createPackageCommand = 'create.package'
-    private packageName!: string
-    private description!: string
-    private keywords!: string[]
-
     private readonly createUiCommand = 'create.ui'
-    private componentName!: string
+    private readonly upgradePackageCommand = 'upgrade.package'
 
     private readonly supportedCommands = [
         this.createImplCommand,
         this.createPackageCommand,
         this.createUiCommand,
+        this.upgradePackageCommand,
     ]
 
     protected constructor(args: string[]) {
@@ -76,384 +67,30 @@ export default class CliCommandRunner implements CommandRunner {
             case this.createUiCommand:
                 await this.createUiModule()
                 break
+            case this.upgradePackageCommand:
+                await this.upgradePackage()
+                break
         }
     }
 
     private async createImplModule() {
-        const { interfaceName, implName } = await this.promptForAutomodule()
-
-        this.interfaceName = interfaceName
-        this.implName = implName
-
-        if (!this.userInputExistsForCreateImpl) {
-            return
-        }
-
-        await this.makeRequiredImplDirectories()
-
-        const automodule = this.ImplAutomodule()
-        await automodule.run()
-    }
-
-    private async promptForAutomodule() {
-        return await this.prompts([
-            {
-                type: 'text',
-                name: 'interfaceName',
-                message: this.interfaceNameMessage,
-            },
-            {
-                type: 'text',
-                name: 'implName',
-                message: this.implNameMessage,
-            },
-        ])
-    }
-
-    private readonly interfaceNameMessage =
-        'What should the interface be called? Example: YourInterface'
-
-    private readonly implNameMessage =
-        'What should the implementation class be called? Example: YourInterfaceImpl'
-
-    private get userInputExistsForCreateImpl() {
-        return this.interfaceName && this.implName
-    }
-
-    private async makeRequiredImplDirectories() {
-        await this.mkdir(this.implTestSaveDir, { recursive: true })
-        await this.mkdir(this.implModuleSaveDir, { recursive: true })
-        await this.mkdir(this.implFakeSaveDir, { recursive: true })
-    }
-
-    private readonly implTestSaveDir = 'src/__tests__/modules'
-    private readonly implModuleSaveDir = 'src/modules'
-
-    private get implFakeSaveDir() {
-        return `src/testDoubles/${this.interfaceName}`
+        const command = new CreateImplCommand()
+        await command.run()
     }
 
     private async createPackage() {
-        const { packageName, description, keywords } =
-            await this.promptForAutopackage()
-
-        this.packageName = packageName
-        this.description = description
-        this.keywords = keywords
-
-        if (!this.userInputExistsForCreatePackage) {
-            return
-        }
-
-        const autopackage = this.NpmAutopackage()
-        await autopackage.run()
-    }
-
-    private async promptForAutopackage() {
-        return await this.prompts([
-            {
-                type: 'text',
-                name: 'packageName',
-                message: this.packageNameMessage,
-            },
-            {
-                type: 'text',
-                name: 'description',
-                message: this.descriptionMessage,
-            },
-            {
-                type: 'text',
-                name: 'keywords',
-                message: this.keywordsMessage,
-                initial: '',
-                format: (value) =>
-                    value ? this.splitOnCommaOrWhitespace(value) : [],
-            },
-        ])
-    }
-
-    private readonly packageNameMessage =
-        'What should the package be called? Example: useful-package'
-
-    private readonly descriptionMessage =
-        'What should the package description be? Example: A useful package.'
-
-    private readonly keywordsMessage =
-        'Enter keywords (comma or space separated, lowercase, optional):'
-
-    private splitOnCommaOrWhitespace(value: string) {
-        return value
-            .split(/[\s,]+/)
-            .map((v: string) => v.trim())
-            .filter(Boolean)
-    }
-
-    private get userInputExistsForCreatePackage() {
-        return this.packageName && this.description
+        const command = new CreatePackageCommand()
+        await command.run()
     }
 
     private async createUiModule() {
-        await this.installDependenciesIfNeeded()
-
-        const { componentName } = await this.promptForUimodule()
-
-        this.componentName = componentName
-
-        if (!this.componentName) {
-            return
-        }
-
-        await this.makeRequiredUiDirectories()
-
-        const instance = this.UiAutomodule()
-        await instance.run()
-    }
-
-    private async installDependenciesIfNeeded() {
-        const isInstalled = await this.checkIfDependenciesAreInstalled()
-
-        if (!isInstalled) {
-            const { shouldInstall } = await this.promptForInstallDependencies()
-
-            if (shouldInstall) {
-                await this.installReactDependencies()
-                await this.updateTsconfigForReact()
-                await this.createSetupTestsFile()
-                await this.addSetupTestsToPackageJson()
-                await this.recompileForTsxFiles()
-            }
-        }
-    }
-
-    private async checkIfDependenciesAreInstalled() {
-        const original = await this.loadPackageJson()
-        const parsed = JSON.parse(original)
-
-        const dependencies = Object.keys(parsed.dependencies ?? {})
-
-        const areDepsInstalled = this.requiredDependencies.every((dep) =>
-            dependencies.includes(dep)
-        )
-
-        const devDependencies = Object.keys(parsed.devDependencies ?? {})
-
-        const areDevDepsInstalled = this.requiredDevDependencies.every((dep) =>
-            devDependencies.includes(dep)
-        )
-
-        return areDepsInstalled && areDevDepsInstalled
-    }
-
-    private async loadPackageJson() {
-        return await this.readFile(this.packageJsonPath, 'utf-8')
-    }
-
-    private readonly packageJsonPath = 'package.json'
-
-    private readonly requiredDependencies = ['react', 'react-dom']
-
-    private readonly requiredDevDependencies = [
-        '@types/react',
-        '@types/react-dom',
-        '@types/jsdom',
-        '@testing-library/react',
-        '@testing-library/dom',
-        '@testing-library/jest-dom',
-        'jsdom',
-    ]
-
-    private async promptForInstallDependencies() {
-        return await this.prompts([
-            {
-                type: 'confirm',
-                name: 'shouldInstall',
-                message:
-                    'Some required dependencies are missing! Press Enter to install, or any other key to abort.',
-                initial: true,
-            },
-        ])
-    }
-
-    private async installReactDependencies() {
-        await this.installDependencies()
-        await this.installDevDependencies()
-    }
-
-    private async installDependencies() {
-        console.log('Installing required dependencies...')
-        await this.exec('yarn add react react-dom')
-    }
-
-    private async installDevDependencies() {
-        console.log('Installing required dev dependencies...')
-        await this.exec(
-            'yarn add -D @types/react @types/react-dom @types/jsdom @testing-library/react @testing-library/dom @testing-library/jest-dom jsdom'
-        )
-    }
-
-    private async updateTsconfigForReact() {
-        console.log('Updating tsconfig.json for React...')
-
-        const original = await this.loadTsconfig()
-        const parsed = JSON.parse(original)
-
-        const updated = JSON.stringify(
-            {
-                ...parsed,
-                compilerOptions: {
-                    jsx: 'react-jsx',
-                    ...parsed.compilerOptions,
-                },
-                include: ['src'],
-            },
-            null,
-            4
-        )
-
-        await this.writeFile(this.tsconfigPath, updated)
-    }
-
-    private async loadTsconfig() {
-        return await this.readFile(this.tsconfigPath, 'utf-8')
-    }
-
-    private readonly tsconfigPath = 'tsconfig.json'
-
-    private async createSetupTestsFile() {
-        console.log('Creating src/setupTests.ts...')
-        await this.writeFile('src/__tests__/setupTests.ts', this.setupTestsFile)
-    }
-
-    private async addSetupTestsToPackageJson() {
-        console.log('Adding setupTests.ts to package.json...')
-
-        const original = await this.loadPackageJson()
-        const parsed = JSON.parse(original)
-
-        const updated = JSON.stringify(
-            {
-                ...parsed,
-                jest: {
-                    ...parsed.jest,
-                    setupFiles: ['<rootDir>/build/__tests__/setupTests.js'],
-                },
-            },
-            null,
-            4
-        )
-
-        await this.writeFile(this.packageJsonPath, updated)
-    }
-
-    private async recompileForTsxFiles() {
-        console.log('Recompiling project for .tsx files...')
-        await this.exec('npx tsc')
-    }
-
-    private async promptForUimodule() {
-        return await this.prompts([
-            {
-                type: 'text',
-                name: 'componentName',
-                message: this.componentNameMessage,
-            },
-        ])
-    }
-
-    private readonly componentNameMessage =
-        'What should the component be called? Example: YourComponent'
-
-    private async makeRequiredUiDirectories() {
-        await this.mkdir(this.uiTestSaveDir, { recursive: true })
-        await this.mkdir(this.uiModuleSaveDir, { recursive: true })
-        await this.mkdir(this.uiFakeSaveDir, { recursive: true })
-    }
-
-    private expandHomeDir(inputPath: string): string {
-        return inputPath.startsWith('~')
-            ? path.join(os.homedir(), inputPath.slice(1))
-            : inputPath
-    }
-
-    private readonly uiTestSaveDir = 'src/__tests__/ui'
-    private readonly uiModuleSaveDir = 'src/ui'
-
-    private get uiFakeSaveDir() {
-        return `src/testDoubles/${this.componentName}`
-    }
-
-    private get exec() {
-        return CliCommandRunner.exec
-    }
-
-    private get mkdir() {
-        return CliCommandRunner.mkdir
-    }
-
-    private get prompts() {
-        return CliCommandRunner.prompts
-    }
-
-    private get readFile() {
-        return CliCommandRunner.readFile
-    }
-
-    private get writeFile() {
-        return CliCommandRunner.writeFile
-    }
-
-    private readonly setupTestsFile = `
-        import { JSDOM } from 'jsdom'
-
-        const jsdom = new JSDOM('<!doctype html><html><body></body></html>', {
-            url: 'http://localhost',
-        })
-
-        global.window = jsdom.window as unknown as Window & typeof globalThis
-        global.document = jsdom.window.document
-        global.navigator = jsdom.window.navigator
-        global.HTMLElement = jsdom.window.HTMLElement
-        global.getComputedStyle = jsdom.window.getComputedStyle
-
-        global.ResizeObserver = class {
-            public observe() {}
-            public unobserve() {}
-            public disconnect() {}
-        }
-
-        global.SVGElement = jsdom.window.SVGElement
-    `
-
-    private ImplAutomodule() {
-        return ImplAutomodule.Create({
-            testSaveDir: this.implTestSaveDir,
-            moduleSaveDir: this.implModuleSaveDir,
-            fakeSaveDir: this.implFakeSaveDir,
-            interfaceName: this.interfaceName,
-            implName: this.implName,
-        })
-    }
-
-    private UiAutomodule() {
-        return UiAutomodule.Create({
-            testSaveDir: this.uiTestSaveDir,
-            moduleSaveDir: this.uiModuleSaveDir,
-            fakeSaveDir: this.uiFakeSaveDir,
-            componentName: this.componentName,
-        })
+        const command = new CreateUiCommand()
+        await command.run()
     }
 
-    private NpmAutopackage() {
-        return NpmAutopackage.Create({
-            name: this.packageName,
-            description: this.description,
-            keywords: ['nodejs', 'typescript', 'tdd', ...this.keywords],
-            gitNamespace: 'neurodevs',
-            npmNamespace: 'neurodevs',
-            installDir: this.expandHomeDir('~/dev'),
-            license: 'MIT',
-            author: 'Eric Yates <hello@ericthecurious.com>',
-        })
+    private async upgradePackage() {
+        const command = new UpgradePackageCommand()
+        await command.run()
     }
 }
 

package/src/modules/commands/CreateImplCommand.ts

@@ -0,0 +1,81 @@
+import { ImplAutomodule } from '@neurodevs/meta-node'
+import CliCommandRunner from '../CliCommandRunner'
+
+export default class CreateImplCommand {
+    private interfaceName!: string
+    private implName!: string
+
+    public constructor() {}
+
+    public async run() {
+        const { interfaceName, implName } = await this.promptForAutomodule()
+
+        this.interfaceName = interfaceName
+        this.implName = implName
+
+        if (!this.userInputExistsForCreateImpl) {
+            return
+        }
+
+        await this.makeRequiredImplDirectories()
+
+        const automodule = this.ImplAutomodule()
+        await automodule.run()
+    }
+
+    private async promptForAutomodule() {
+        return await this.prompts([
+            {
+                type: 'text',
+                name: 'interfaceName',
+                message: this.interfaceNameMessage,
+            },
+            {
+                type: 'text',
+                name: 'implName',
+                message: this.implNameMessage,
+            },
+        ])
+    }
+
+    private readonly interfaceNameMessage =
+        'What should the interface be called? Example: YourInterface'
+
+    private readonly implNameMessage =
+        'What should the implementation class be called? Example: YourInterfaceImpl'
+
+    private get userInputExistsForCreateImpl() {
+        return this.interfaceName && this.implName
+    }
+
+    private async makeRequiredImplDirectories() {
+        await this.mkdir(this.implTestSaveDir, { recursive: true })
+        await this.mkdir(this.implModuleSaveDir, { recursive: true })
+        await this.mkdir(this.implFakeSaveDir, { recursive: true })
+    }
+
+    private readonly implTestSaveDir = 'src/__tests__/modules'
+    private readonly implModuleSaveDir = 'src/modules'
+
+    private get implFakeSaveDir() {
+        return `src/testDoubles/${this.interfaceName}`
+    }
+
+    private get mkdir() {
+        return CliCommandRunner.mkdir
+    }
+
+    private get prompts() {
+        return CliCommandRunner.prompts
+    }
+
+    private ImplAutomodule() {
+        return ImplAutomodule.Create({
+            testSaveDir: this.implTestSaveDir,
+            moduleSaveDir: this.implModuleSaveDir,
+            fakeSaveDir: this.implFakeSaveDir,
+            interfaceName: this.interfaceName,
+            implName: this.implName,
+        })
+    }
+}