@sprucelabs/spruce-cli 24.0.0 → 24.1.1

package/src/features/test/actions/MigrateAction.ts

@@ -0,0 +1,44 @@
+import { buildSchema } from '@sprucelabs/schema'
+import { diskUtil } from '@sprucelabs/spruce-skill-utils'
+import StaticTestFinderImpl from '../../../tests/staticToInstanceMigration/StaticTestFinder'
+import StaticToInstanceMigratorImpl from '../../../tests/staticToInstanceMigration/StaticToInstanceMigrator'
+import StaticToInstanceTestFileMigratorImpl from '../../../tests/staticToInstanceMigration/StaticToInstanceTestFileMigrator'
+import AbstractAction from '../../AbstractAction'
+import { FeatureActionResponse } from '../../features.types'
+
+export default class MigrationAction extends AbstractAction<OptionsSchema> {
+    public optionsSchema = optionsSchema
+    public commandAliases = ['migrate.tests']
+    public invocationMessage = 'Migrating tests from static to instance... 🌲'
+
+    public async execute(): Promise<FeatureActionResponse> {
+        const testFinder = StaticTestFinderImpl.Finder()
+        const testFileMigrator = StaticToInstanceTestFileMigratorImpl.Migrator()
+        const lintService = this.Service('lint')
+        const migrator = StaticToInstanceMigratorImpl.Migrator({
+            testFinder,
+            testFileMigrator,
+            lintService,
+        })
+
+        this.ui.startLoading('Migrating tests...')
+        const path = diskUtil.resolvePath(this.cwd, 'src', '__tests__')
+        const { totalTestsSkipped, totalTestsUpdated } =
+            await migrator.run(path)
+
+        return {
+            headline: 'Migrated tests from static to instance based.',
+            summaryLines: [
+                `${totalTestsUpdated} test${totalTestsUpdated === 1 ? '' : 's'} updated`,
+                `${totalTestsSkipped} test${totalTestsSkipped === 1 ? '' : 's'} skipped`,
+            ],
+        }
+    }
+}
+
+const optionsSchema = buildSchema({
+    id: 'migrateTests',
+    fields: {},
+})
+
+type OptionsSchema = typeof optionsSchema

package/src/features/vscode/services/VsCodeService.ts

@@ -1,7 +1,7 @@
 import semver from 'semver'
-import CommandService from '../../../services/CommandService'
+import CommandServiceImpl from '../../../services/CommandService'
 
-export default class VsCodeService extends CommandService {
+export default class VsCodeService extends CommandServiceImpl {
     /** Returns whether or not vscode is installed */
     public async isInstalled(): Promise<boolean> {
         const isInstalled = false

package/src/services/BuildService.ts

@@ -1,4 +1,4 @@
-import CommandService from './CommandService'
+import CommandServiceImpl from './CommandService'
 import LintService from './LintService'
 
 export default class BuildService {
@@ -10,11 +10,11 @@ export default class BuildService {
         return this.commandService.cwd
     }
 
-    private commandService: CommandService
+    private commandService: CommandServiceImpl
     private lintService: LintService
 
     public constructor(
-        commandService: CommandService,
+        commandService: CommandServiceImpl,
         lintService: LintService
     ) {
         this.commandService = commandService

package/src/services/CommandService.ts

@@ -9,7 +9,7 @@ import SpruceError from '../errors/SpruceError'
 
 process.setMaxListeners(100)
 
-export default class CommandService {
+export default class CommandServiceImpl implements CommandService {
     public cwd: string
     private activeChildProcess: ChildProcess | undefined
     private ignoreCloseErrors = false
@@ -25,17 +25,7 @@ export default class CommandService {
 
     public async execute(
         cmd: string,
-        options?: {
-            ignoreErrors?: boolean
-            args?: string[]
-            shouldStream?: boolean
-            outStream?: Writable
-            onError?: (error: string) => void
-            onData?: (data: string) => void
-            spawnOptions?: SpawnOptions
-            forceColor?: boolean
-            env?: Record<string, any>
-        }
+        options?: ExecuteCommandOptions
     ): Promise<{
         stdout: string
     }> {
@@ -51,7 +41,7 @@ export default class CommandService {
         const { mockResponse, mockKey } = this.getMockResponse(executable, args)
 
         if (mockResponse) {
-            CommandService.commandsRunCapturedByMockResponses.push(mockKey)
+            CommandServiceImpl.commandsRunCapturedByMockResponses.push(mockKey)
             mockResponse.callback?.(executable, args)
 
             if (mockResponse.code !== 0) {
@@ -174,7 +164,7 @@ export default class CommandService {
 
     private getMockResponse(executable: string, args: string[]) {
         const mockKey = `${executable} ${args.join(' ')}`.trim()
-        const commands = CommandService.fakeResponses
+        const commands = CommandServiceImpl.fakeResponses
         const match = commands.find((r) =>
             r.command instanceof RegExp
                 ? mockKey.search(r.command) > -1
@@ -208,3 +198,26 @@ interface FakedCommandResponse {
     stderr?: string
     callback?: FakedCommandCallback
 }
+
+export interface CommandService {
+    execute(
+        cmd: string,
+        options?: ExecuteCommandOptions
+    ): Promise<{
+        stdout: string
+    }>
+    kill(): void
+    pid(): number | undefined
+}
+
+export interface ExecuteCommandOptions {
+    ignoreErrors?: boolean
+    args?: string[]
+    shouldStream?: boolean
+    outStream?: Writable
+    onError?: (error: string) => void
+    onData?: (data: string) => void
+    spawnOptions?: SpawnOptions
+    forceColor?: boolean
+    env?: Record<string, any>
+}

package/src/services/GameService.ts

@@ -1,14 +1,14 @@
 import { diskUtil } from '@sprucelabs/spruce-skill-utils'
 import TerminalInterface from '../interfaces/TerminalInterface'
-import CommandService from './CommandService'
+import CommandServiceImpl from './CommandService'
 
 export default class GameService {
-    private command: CommandService
+    private command: CommandServiceImpl
     private ui: TerminalInterface
     private statusMessage?: string
     private killed = false
 
-    public constructor(command: CommandService, ui: TerminalInterface) {
+    public constructor(command: CommandServiceImpl, ui: TerminalInterface) {
         this.command = command
         this.ui = ui
         this.command.cwd = diskUtil.resolvePath(__dirname, '../../')

package/src/services/ImportService.ts

@@ -3,7 +3,7 @@ import { diskUtil } from '@sprucelabs/spruce-skill-utils'
 import fs from 'fs-extra'
 import md5 from 'md5'
 import SpruceError from '../errors/SpruceError'
-import CommandService from './CommandService'
+import CommandServiceImpl from './CommandService'
 
 export default class ImportService {
     public cwd: string
@@ -14,10 +14,10 @@ export default class ImportService {
     private static cachedImports: Record<string, Record<string, any>> = {}
     private static importCacheDir: string =
         diskUtil.createTempDir('import-service')
-    private command: CommandService
+    private command: CommandServiceImpl
     private static isCachingEnabled: boolean
 
-    public constructor(options: { cwd: string; command: CommandService }) {
+    public constructor(options: { cwd: string; command: CommandServiceImpl }) {
         this.cwd = options.cwd
         this.command = options.command
     }

package/src/services/LintService.ts

@@ -2,7 +2,7 @@ import { SchemaError } from '@sprucelabs/schema'
 // import { ESLint } from 'eslint'
 // import fs from 'fs-extra'
 import SpruceError from '../errors/SpruceError'
-import CommandService from './CommandService'
+import { CommandService } from './CommandService'
 
 export default class LintService {
     public cwd: string

package/src/services/PkgService.ts

@@ -4,12 +4,12 @@ import {
     PkgService as BasePkgService,
 } from '@sprucelabs/spruce-skill-utils'
 import isCi from '../utilities/isCi'
-import CommandService from './CommandService'
+import CommandServiceImpl from './CommandService'
 
 export default class PkgService extends BasePkgService {
-    private commandService: CommandService
+    private commandService: CommandServiceImpl
 
-    public constructor(cwd: string, commandService: CommandService) {
+    public constructor(cwd: string, commandService: CommandServiceImpl) {
         super(cwd)
         this.commandService = commandService
     }

package/src/services/ServiceFactory.ts

@@ -9,7 +9,7 @@ import { FeatureCode } from '../features/features.types'
 import SchemaService from '../features/schema/services/SchemaService'
 import VsCodeService from '../features/vscode/services/VsCodeService'
 import BuildService from './BuildService'
-import CommandService from './CommandService'
+import CommandServiceImpl from './CommandService'
 import DependencyService from './DependencyService'
 import ImportService from './ImportService'
 import LintService from './LintService'
@@ -41,14 +41,14 @@ export default class ServiceFactory {
             case 'schema':
                 return new SchemaService({
                     cwd,
-                    command: new CommandService(cwd),
+                    command: new CommandServiceImpl(cwd),
                 }) as ServiceMap[S]
             case 'lint':
                 return new (Class ?? LintService)(cwd, () =>
                     this.Service(cwd, 'command')
                 ) as ServiceMap[S]
             case 'command': {
-                return new CommandService(cwd) as ServiceMap[S]
+                return new CommandServiceImpl(cwd) as ServiceMap[S]
             }
             case 'remote':
                 return new RemoteService(new EnvService(cwd)) as ServiceMap[S]
@@ -68,7 +68,7 @@ export default class ServiceFactory {
             case 'import':
                 return this.buildImportService(cwd) as ServiceMap[S]
             case 'build': {
-                const commandService = new CommandService(cwd)
+                const commandService = new CommandServiceImpl(cwd)
                 return new BuildService(
                     commandService,
                     this.Service(cwd, 'lint')
@@ -86,7 +86,7 @@ export default class ServiceFactory {
     private buildImportService(cwd: string): ImportService {
         return new ImportService({
             cwd,
-            command: new CommandService(cwd),
+            command: new CommandServiceImpl(cwd),
         })
     }
 
@@ -104,7 +104,7 @@ export interface ServiceMap {
     vsCode: VsCodeService
     schema: SchemaService
     lint: LintService
-    command: CommandService
+    command: CommandServiceImpl
     typeChecker: TypeCheckerService
     import: ImportService
     build: BuildService

package/src/tests/AbstractCliTest.ts

@@ -22,7 +22,7 @@ import OnboardingStore from '../features/onboard/stores/OnboardingStore'
 import SkillStore from '../features/skill/stores/SkillStore'
 import CliGlobalEmitter, { GlobalEmitter } from '../GlobalEmitter'
 import SpyInterface from '../interfaces/SpyInterface'
-import CommandService from '../services/CommandService'
+import CommandServiceImpl from '../services/CommandService'
 import ImportService from '../services/ImportService'
 import LintService from '../services/LintService'
 import ServiceFactory, { Service, ServiceMap } from '../services/ServiceFactory'
@@ -114,7 +114,7 @@ export default abstract class AbstractCliTest extends AbstractSpruceTest {
         ImportService.clearCache()
         SkillStore.clearCurrentSkill()
         EventStore.clearCache()
-        CommandService.clearFakedResponses()
+        CommandServiceImpl.clearFakedResponses()
         MercuryClientFactory.reset()
         MercuryClientFactory.setIsTestMode(false)
 

package/src/tests/CommandFaker.ts

@@ -1,24 +1,24 @@
 import { assert } from '@sprucelabs/test-utils'
-import CommandService from '../services/CommandService'
+import CommandServiceImpl from '../services/CommandService'
 
 type Command = RegExp | string
 
 export default class CommandFaker {
     public fakeCommand(command: Command, code = 0) {
-        CommandService.fakeCommand(command, {
+        CommandServiceImpl.fakeCommand(command, {
             code,
         })
     }
 
     public on(command: Command, cb: () => void) {
-        CommandService.fakeCommand(command, {
+        CommandServiceImpl.fakeCommand(command, {
             code: 0,
             callback: cb,
         })
     }
 
     public makeCommandThrow(command: Command) {
-        CommandService.fakeCommand(command, {
+        CommandServiceImpl.fakeCommand(command, {
             code: 1,
             callback: () =>
                 assert.fail(`${command} should not have been called`),

package/src/tests/staticToInstanceMigration/StaticTestFinder.ts

@@ -0,0 +1,25 @@
+import globby from '@sprucelabs/globby'
+import { assertOptions } from '@sprucelabs/schema'
+
+export default class StaticTestFinderImpl implements StaticTestFinder {
+    public static Class?: new () => StaticTestFinder
+
+    public static Finder(): StaticTestFinder {
+        return new (this.Class ?? this)()
+    }
+
+    public async find(lookupDir: string) {
+        assertOptions({ lookupDir }, ['lookupDir'])
+
+        const matches = await globby([
+            `${lookupDir}/**/Abstract*Test.ts`,
+            `${lookupDir}/**/*.test.ts`,
+        ])
+
+        return matches
+    }
+}
+
+export interface StaticTestFinder {
+    find(lookupDir: string): Promise<string[]>
+}

package/src/tests/staticToInstanceMigration/StaticToInstanceMigrator.ts

@@ -0,0 +1,83 @@
+import { assertOptions } from '@sprucelabs/schema'
+import { diskUtil } from '@sprucelabs/spruce-skill-utils'
+import LintService from '../../services/LintService'
+import StaticTestFinder from './StaticTestFinder'
+import { StaticToInstanceTestFileMigrator } from './StaticToInstanceTestFileMigrator'
+
+export default class StaticToInstanceMigratorImpl
+    implements StaticToInstanceMigrator
+{
+    public static diskUtil = diskUtil
+    public static Class?: new (
+        options: StaticToInstanceMigratorOptions
+    ) => StaticToInstanceMigrator
+
+    private testFinder: StaticTestFinder
+    private testFileMigrator: StaticToInstanceTestFileMigrator
+    private lintService: LintService
+
+    protected constructor(options: StaticToInstanceMigratorOptions) {
+        const { testFinder, testFileMigrator, lintService } = options
+        this.testFinder = testFinder
+        this.testFileMigrator = testFileMigrator
+        this.lintService = lintService
+    }
+
+    public static Migrator(options: StaticToInstanceMigratorOptions) {
+        assertOptions(options, [
+            'testFinder',
+            'testFileMigrator',
+            'lintService',
+        ])
+        return new (this.Class ?? this)(options)
+    }
+
+    public async run(lookupDir: string) {
+        assertOptions({ lookupDir }, ['lookupDir'])
+        const matches = await this.testFinder.find(lookupDir)
+
+        let totalTestsUpdated = 0
+        let totalTestsSkipped = 0
+
+        for (const match of matches) {
+            const contents = this.readFile(match)
+            const updated = this.testFileMigrator.migrate(contents)
+            if (contents === updated) {
+                totalTestsSkipped++
+            } else {
+                totalTestsUpdated++
+                this.writeFile(match, updated)
+            }
+        }
+
+        await this.lintService.fix('**/*.ts')
+
+        return {
+            totalTestsUpdated,
+            totalTestsSkipped,
+        }
+    }
+
+    private readFile(match: string) {
+        return StaticToInstanceMigratorImpl.diskUtil.readFile(match)
+    }
+
+    private writeFile(match: string, updated: string) {
+        StaticToInstanceMigratorImpl.diskUtil.writeFile(match, updated)
+    }
+}
+
+export interface StaticToInstanceMigratorOptions {
+    testFinder: StaticTestFinder
+    testFileMigrator: StaticToInstanceTestFileMigrator
+    lintService: LintService
+}
+
+export interface StaticToInstanceMigratorResults {
+    totalTestsUpdated: number
+    totalTestsSkipped: number
+}
+
+export interface StaticToInstanceMigrator {
+    run(lookupDir: string): Promise<StaticToInstanceMigratorResults>
+}

package/src/tests/staticToInstanceMigration/StaticToInstanceTestFileMigrator.ts

@@ -0,0 +1,197 @@
+import { assertOptions } from '@sprucelabs/schema'
+
+export default class StaticToInstanceTestFileMigratorImpl
+    implements StaticToInstanceTestFileMigrator
+{
+    public static Class?: new () => StaticToInstanceTestFileMigrator
+
+    public static Migrator() {
+        return new (this.Class ?? this)()
+    }
+
+    public migrate(contents: string) {
+        assertOptions({ contents }, ['contents'])
+
+        // 1a. Remove `static ` only when it appears immediately before a method
+        //    that has the `@test()` decorator
+        // 1b. If the contents include `export default abstract class`,
+        //     remove `static` from all methods
+        const includesAbstractExport = contents.includes(
+            'export default abstract class'
+        )
+        let cleanedUp = includesAbstractExport
+            ? contents.replaceAll(' static ', ' ')
+            : contents.replace(
+                  // Matches @test() or @seed(...) followed (on next line) by optional visibility and `static`.
+                  /(@(?:test\(\)|seed\([^)]*\))\s*\n\s*(?:public|protected)\s+)static\s+/g,
+                  '$1'
+              )
+
+        // 2. Add `@suite()` above `export default class` if it's not already present
+        if (!cleanedUp.includes('@suite')) {
+            cleanedUp = cleanedUp.replace(
+                /export default class/,
+                '@suite()\nexport default class'
+            )
+        }
+
+        // 3. Ensure `suite` is imported from `@sprucelabs/test-utils`
+        if (!this.hasSuiteImport(cleanedUp)) {
+            if (cleanedUp.includes('{ test')) {
+                cleanedUp = cleanedUp.replace('{ test', '{ test, suite')
+            } else if (cleanedUp.includes('test }')) {
+                cleanedUp = cleanedUp.replace('test }', 'test, suite }')
+            } else {
+                cleanedUp = cleanedUp.replace('test,', 'test,\n    suite,')
+            }
+        }
+
+        const thisCallNames = this.findThisCalls(cleanedUp)
+        for (const name of thisCallNames) {
+            cleanedUp = this.removeStaticFromDeclaration(cleanedUp, name)
+        }
+
+        // 4. lifecicle methods
+        const methods = ['beforeEach', 'afterEach']
+        for (const method of methods) {
+            cleanedUp = cleanedUp.replace(
+                `protected static async ${method}()`,
+                `protected async ${method}()`
+            )
+        }
+
+        cleanedUp = this.fixNonNullAssertions(cleanedUp)
+
+        return cleanedUp
+    }
+
+    private hasSuiteImport(text: string): boolean {
+        const pattern = new RegExp(
+            `import\\s+(?:[\\s\\S]*?\\bsuite\\b[\\s\\S]*?)\\s+from\\s+['"]@sprucelabs/test-utils['"]`
+        )
+        return pattern.test(text)
+    }
+
+    private findThisCalls(contents: string): string[] {
+        // Matches `this.myProp` if followed by space, punctuation, parentheses, or end of string
+        const thisPropertyRegex = /this\.(\w+)(?=[\s.(),;]|$)/g
+        const names: string[] = []
+        let match: RegExpExecArray | null
+
+        while ((match = thisPropertyRegex.exec(contents)) !== null) {
+            const propName = match[1]
+            if (!names.includes(propName)) {
+                names.push(propName)
+            }
+        }
+
+        return names
+    }
+
+    private removeStaticFromDeclaration(
+        contents: string,
+        name: string
+    ): string {
+        /**
+         * 1) Remove `static` for methods/getters/setters, e.g.:
+         *    private static async doSomething() => private async doSomething()
+         *    private static get value() => private get value()
+         *    private static set value(v) => private set value(v)
+         */
+        const methodPattern = new RegExp(
+            `((?:public|protected|private)?\\s+)?` + // group 1
+                `static\\s+` + // literal "static "
+                `(?:(async)\\s+)?` + // group 2: "async"?
+                `(?:(get|set)\\s+)?` + // group 3: "get" or "set"?
+                `(${name})\\s*\\(`, // group 4: the identifier + '('
+            'g'
+        )
+        let updated = contents.replace(
+            methodPattern,
+            (match, g1, g2, g3, g4) => {
+                const asyncPart = g2 ? g2 + ' ' : ''
+                const accessorPart = g3 ? g3 + ' ' : ''
+                // Rebuild the declaration without "static"
+                return `${g1 ?? ''}${asyncPart}${accessorPart}${g4}(`
+            }
+        )
+
+        /**
+         * 2) Remove `static` from property declarations and add a non-null assertion.
+         *    e.g.
+         *    private static myProp: Type => private myProp!: Type
+         */
+        const propertyPattern = new RegExp(
+            `((?:public|protected|private)?\\s+)?` + // group 1: optional visibility
+                `static\\s+` + // literal "static "
+                `(${name})` + // group 2: the property name
+                `(?=[\\s=:\\[;]|$)`, // lookahead: space, '=', ':', '[', ';', or end-of-string
+            'g'
+        )
+        updated = updated.replace(propertyPattern, (match, g1, g2) => {
+            // g1 = "private " / "public " / "protected " or empty
+            // g2 = property name
+            return `${g1 ?? ''}${g2}!`
+        })
+
+        return updated
+    }
+
+    private fixNonNullAssertions(contents: string): string {
+        const lines = contents.split('\n')
+
+        const propertyRegex =
+            /^(\s*)(public|protected|private)(\s+readonly)?\s+(\w+)\s*(!)?\s*:\s*([^=;]+)(=.*)?;?$/
+
+        const updatedLines = lines.map((originalLine) => {
+            // Skip lines containing "static"
+            if (originalLine.includes('static')) {
+                return originalLine
+            }
+
+            const match = originalLine.match(propertyRegex)
+            if (!match) {
+                return originalLine
+            }
+
+            let [
+                ,
+                leadingWhitespace,
+                visibility,
+                readonlyPart = '',
+                propName,
+                exclamation,
+                typeDecl,
+                assignment,
+            ] = match
+
+            // Trim trailing whitespace from the type
+            typeDecl = typeDecl.trim()
+
+            if (assignment) {
+                // Remove the bang if there's an assignment
+                exclamation = ''
+
+                // Remove trailing semicolon
+                assignment = assignment.replace(/;$/, '')
+
+                // Ensure we always have " = " at the start
+                // E.g. "=something" => " = something"
+                assignment = assignment.replace(/^=\s*/, ' = ')
+            } else {
+                // No assignment? Add bang
+                exclamation = '!'
+            }
+
+            // Rebuild line, preserving leading indentation
+            const rebuilt = `${leadingWhitespace}${visibility}${readonlyPart} ${propName}${exclamation}: ${typeDecl}${assignment ?? ''}`
+            return rebuilt
+        })
+
+        return updatedLines.join('\n')
+    }
+}
+
+export interface StaticToInstanceTestFileMigrator {
+    migrate(contents: string): string
+}